+2002-01-11 Miguel de Icaza <miguel@ximian.com>
+
+ * ecore.cs (Expression.MemberLookup): instead of taking a
+ parameter `same_type' that was used to tell whether we could
+ access private members we compute our containing type from the
+ EmitContext.
+
+ Updated all the source files to use this.
+
+ * codegen.cs (EmitContext): Compute ContainerType ahead of time,
+ because it is referenced by MemberLookup very often.
+
2002-01-09 Ravi Pratap <ravi@ximian.com>
* typemanager.cs (IndexerPropertyName): If we have a TypeBuilder, use
EventInfo ei = ((EventExpr) target).EventInfo;
- Expression ml = MemberLookup (ec, ec.TypeContainer.TypeBuilder, ei.Name,
- true, MemberTypes.Event, AllBindingFlags, l);
+ Expression ml = MemberLookup (
+ ec, ec.TypeContainer.TypeBuilder, ei.Name,
+ MemberTypes.Event, AllBindingFlags, l);
if (ml == null) {
//
ArrayList prop_infos = new ArrayList ();\r
ArrayList field_values = new ArrayList ();\r
ArrayList prop_values = new ArrayList ();\r
-\r
+ \r
for (i = 0; i < named_args.Count; i++) {\r
DictionaryEntry de = (DictionaryEntry) named_args [i];\r
string member_name = (string) de.Key;\r
return null;\r
\r
Expression member = Expression.MemberLookup (\r
- ec, Type, member_name, false,\r
+ ec, Type, member_name,\r
MemberTypes.Field | MemberTypes.Property,\r
BindingFlags.Public | BindingFlags.Instance,\r
Location);\r
}\r
\r
Expression mg = Expression.MemberLookup (\r
- ec, Type, ".ctor", false, MemberTypes.Constructor,\r
+ ec, Type, ".ctor", MemberTypes.Constructor,\r
BindingFlags.Public | BindingFlags.Instance, Location);\r
\r
if (mg == null) {\r
bool exact_spelling = false;\r
bool set_last_err = false;\r
string entry_point = null;\r
- \r
+\r
for (int i = 0; i < named_args.Count; i++) {\r
\r
DictionaryEntry de = (DictionaryEntry) named_args [i];\r
if (!a.Resolve (ec, Location))\r
return null;\r
\r
- Expression member = Expression.MemberLookup (ec, Type, member_name, false,\r
- MemberTypes.Field | MemberTypes.Property,\r
- BindingFlags.Public | BindingFlags.Instance,\r
- Location);\r
+ Expression member = Expression.MemberLookup (\r
+ ec, Type, member_name, \r
+ MemberTypes.Field | MemberTypes.Property,\r
+ BindingFlags.Public | BindingFlags.Instance,\r
+ Location);\r
\r
if (member == null || !(member is FieldExpr)) {\r
error617 (member_name);\r
t = ec.TypeContainer.TypeBuilder;
parent_constructor_group = Expression.MemberLookup (
- ec, t, ".ctor", true,
+ ec, t, ".ctor",
MemberTypes.Constructor,
BindingFlags.Public | BindingFlags.Instance, location);
/// </summary>
public Type ReturnType;
+ /// <summary>
+ /// Points to the Type (extracted from the TypeContainer) that
+ /// declares this body of code
+ /// </summary>
+ public Type ContainerType;
+
/// <summary>
/// Whether this is generating code for a constructor
/// </summary>
ReturnType = return_type;
IsConstructor = is_constructor;
CurrentBlock = null;
+ ContainerType = parent.TypeBuilder;
loc = l;
if (ReturnType == TypeManager.void_type)
{\r
ParameterData pd = Invocation.GetParameterData (mb);\r
\r
- Expression ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc);\r
+ Expression ml = Expression.MemberLookup (\r
+ ec, delegate_type, "Invoke", loc);\r
\r
if (!(ml is MethodGroupExpr)) {\r
Report.Error (-100, loc, "Internal error : could not find Invoke method!");\r
else\r
arg_count = args.Count;\r
\r
- Expression ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc);\r
+ Expression ml = Expression.MemberLookup (\r
+ ec, delegate_type, "Invoke", loc);\r
\r
if (!(ml is MethodGroupExpr)) {\r
Report.Error (-100, loc, "Internal error : could not find Invoke method!");\r
/// </summary>\r
public static bool VerifyDelegate (EmitContext ec, Type delegate_type, Type probe_type, Location loc)\r
{\r
- Expression ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc);\r
+ Expression ml = Expression.MemberLookup (\r
+ ec, delegate_type, "Invoke", loc);\r
\r
if (!(ml is MethodGroupExpr)) {\r
Report.Error (-100, loc, "Internal error : could not find Invoke method!");\r
MethodBase mb = ((MethodGroupExpr) ml).Methods [0];\r
ParameterData pd = Invocation.GetParameterData (mb);\r
\r
- Expression probe_ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc);\r
+ Expression probe_ml = Expression.MemberLookup (\r
+ ec, delegate_type, "Invoke", loc);\r
\r
if (!(probe_ml is MethodGroupExpr)) {\r
Report.Error (-100, loc, "Internal error : could not find Invoke method!");\r
return null;\r
}\r
\r
- Expression ml = Expression.MemberLookup (ec, type, ".ctor", false, Location);\r
+ Expression ml = Expression.MemberLookup (\r
+ ec, type, ".ctor", Location);\r
\r
if (!(ml is MethodGroupExpr)) {\r
Report.Error (-100, Location, "Internal error : Could not find delegate constructor!");\r
return null;\r
}\r
\r
- Expression invoke_method = Expression.MemberLookup (ec, e_type, "Invoke", false,\r
- MemberTypes.Method,\r
- Expression.AllBindingFlags,\r
- Location);\r
+ Expression invoke_method = Expression.MemberLookup (\r
+ ec, e_type, "Invoke", MemberTypes.Method,\r
+ Expression.AllBindingFlags, Location);\r
\r
if (invoke_method == null) {\r
Report.Error (-200, Location, "Internal error ! COuld not find Invoke method!");\r
if (!Delegate.VerifyApplicability (ec, del_type, Arguments, Location))\r
return null;\r
\r
- Expression ml = Expression.MemberLookup (ec, del_type, "Invoke", false, Location);\r
+ Expression ml = Expression.MemberLookup (ec, del_type, "Invoke", Location);\r
\r
if (!(ml is MethodGroupExpr)) {\r
Report.Error (-100, Location, "Internal error : could not find Invoke method!");\r
//
// FIXME: Probably implement a cache for (t,name,current_access_set)?
//
- // FIXME: We need to cope with access permissions here, or this wont
- // work!
- //
// This code could use some optimizations, but we need to do some
// measurements. For example, we could use a delegate to `flag' when
// something can not any longer be a method-group (because it is something
//
// FIXME: Potential optimization, have a static ArrayList
//
+
public static Expression MemberLookup (EmitContext ec, Type t, string name,
- bool same_type, MemberTypes mt,
- BindingFlags bf, Location loc)
+ MemberTypes mt, BindingFlags bf, Location loc)
{
- if (same_type)
+ Type source_type = ec.ContainerType;
+
+ if (source_type == t || source_type.IsSubclassOf (t))
bf |= BindingFlags.NonPublic;
//
BindingFlags.Static |
BindingFlags.Instance;
- public static Expression MemberLookup (EmitContext ec, Type t, string name,
- bool same_type, Location loc)
+ public static Expression MemberLookup (EmitContext ec, Type t, string name, Location loc)
{
- return MemberLookup (ec, t, name, same_type, AllMemberTypes, AllBindingFlags, loc);
+ return MemberLookup (ec, t, name, AllMemberTypes, AllBindingFlags, loc);
}
+ /// <summary>
+ /// This is a wrapper for MemberLookup that is not used to "probe", but
+ /// to find a final definition. If the final definition is not found, we
+ /// look for private members and display a useful debugging message if we
+ /// find it.
+ /// </summary>
+ public static Expression MemberLookupFinal (EmitContext ec, Type t, string name,
+ Location loc)
+ {
+ Expression e;
+
+ e = MemberLookup (ec, t, name, AllMemberTypes, AllBindingFlags, loc);
+
+ if (e != null)
+ return e;
+
+ e = MemberLookup (ec, t, name, AllMemberTypes,
+ AllBindingFlags | BindingFlags.NonPublic, loc);
+ if (e == null){
+ Report.Error (
+ 117, loc, "`" + t + "' does not contain a definition " +
+ "for `" + name + "'");
+ } else {
+ Report.Error (
+ 122, loc, "`" + t + "." + name +
+ "' is inaccessible due to its protection level");
+ }
+
+ return null;
+ }
+
static public Expression ImplicitReferenceConversion (Expression expr, Type target_type)
{
Type expr_type = expr.Type;
else
op_name = "op_Implicit";
- mg1 = MemberLookup (ec, source_type, op_name, false, loc);
+ mg1 = MemberLookup (ec, source_type, op_name, loc);
if (source_type.BaseType != null)
- mg2 = MemberLookup (ec, source_type.BaseType, op_name, false, loc);
+ mg2 = MemberLookup (ec, source_type.BaseType, op_name, loc);
- mg3 = MemberLookup (ec, target, op_name, false, loc);
+ mg3 = MemberLookup (ec, target, op_name, loc);
if (target.BaseType != null)
- mg4 = MemberLookup (ec, target.BaseType, op_name, false, loc);
+ mg4 = MemberLookup (ec, target.BaseType, op_name, loc);
MethodGroupExpr union1 = Invocation.MakeUnionSet (mg1, mg2);
MethodGroupExpr union2 = Invocation.MakeUnionSet (mg3, mg4);
op_name = "op_Explicit";
- mg5 = MemberLookup (ec, source_type, op_name, false, loc);
+ mg5 = MemberLookup (ec, source_type, op_name, loc);
if (source_type.BaseType != null)
- mg6 = MemberLookup (ec, source_type.BaseType, op_name, false, loc);
+ mg6 = MemberLookup (ec, source_type.BaseType, op_name, loc);
- mg7 = MemberLookup (ec, target, op_name, false, loc);
+ mg7 = MemberLookup (ec, target, op_name, loc);
if (target.BaseType != null)
- mg8 = MemberLookup (ec, target.BaseType, op_name, false, loc);
+ mg8 = MemberLookup (ec, target.BaseType, op_name, loc);
MethodGroupExpr union5 = Invocation.MakeUnionSet (mg5, mg6);
MethodGroupExpr union6 = Invocation.MakeUnionSet (mg7, mg8);
//
// Stage 2: Lookup members
//
- e = MemberLookup (ec, ec.TypeContainer.TypeBuilder, Name, true, Location);
+ e = MemberLookup (ec, ec.TypeContainer.TypeBuilder, Name, Location);
if (e == null){
//
// Stage 3: Lookup symbol in the various namespaces.
Expression ml = MemberLookup (
ec, ec.TypeContainer.TypeBuilder, ee.EventInfo.Name,
- true, MemberTypes.Event, AllBindingFlags, Location);
+ MemberTypes.Event, AllBindingFlags, Location);
if (ml != null) {
MemberInfo mi = ec.TypeContainer.GetFieldFromEvent ((EventExpr) ml);
op_name = oper_names [(int) oper];
- mg = MemberLookup (ec, expr_type, op_name, false, loc);
+ mg = MemberLookup (ec, expr_type, op_name, loc);
if (mg == null && expr_type.BaseType != null)
- mg = MemberLookup (ec, expr_type.BaseType, op_name, false, loc);
+ mg = MemberLookup (ec, expr_type.BaseType, op_name, loc);
if (mg != null) {
Expression e = StaticCallExpr.MakeSimpleCall (
else
op_name = "op_Decrement";
- mg = MemberLookup (ec, expr_type, op_name, false, loc);
+ mg = MemberLookup (ec, expr_type, op_name, loc);
if (mg == null && expr_type.BaseType != null)
- mg = MemberLookup (ec, expr_type.BaseType, op_name, false, loc);
+ mg = MemberLookup (ec, expr_type.BaseType, op_name, loc);
if (mg != null) {
method = StaticCallExpr.MakeSimpleCall (
string op = "op_" + oper;
- left_expr = MemberLookup (ec, l, op, false, loc);
+ left_expr = MemberLookup (ec, l, op, loc);
if (left_expr == null && l.BaseType != null)
- left_expr = MemberLookup (ec, l.BaseType, op, false, loc);
+ left_expr = MemberLookup (ec, l.BaseType, op, loc);
- right_expr = MemberLookup (ec, r, op, false, loc);
+ right_expr = MemberLookup (ec, r, op, loc);
if (right_expr == null && r.BaseType != null)
- right_expr = MemberLookup (ec, r.BaseType, op, false, loc);
+ right_expr = MemberLookup (ec, r.BaseType, op, loc);
MethodGroupExpr union = Invocation.MakeUnionSet (left_expr, right_expr);
//
if (expr is BaseAccess)
is_base = true;
-
+
expr = expr.Resolve (ec);
if (expr == null)
return null;
return this;
Expression ml;
- ml = MemberLookup (ec, type, ".ctor", false,
- MemberTypes.Constructor, AllBindingFlags, loc);
+ ml = MemberLookup (ec, type, ".ctor", MemberTypes.Constructor, AllBindingFlags, loc);
if (! (ml is MethodGroupExpr)){
if (!is_struct){
Expression ml;
- ml = MemberLookup (ec, type, ".ctor", false, MemberTypes.Constructor,
+ ml = MemberLookup (ec, type, ".ctor", MemberTypes.Constructor,
AllBindingFlags, loc);
if (!(ml is MethodGroupExpr)){
"type name instead");
}
-#if USE_OLD
static bool IdenticalNameAndTypeName (EmitContext ec, Expression left_original, Location loc)
{
if (left_original == null)
if (decl_type.IsSubclassOf (TypeManager.enum_type)) {
Expression enum_member = MemberLookup (
- ec, decl_type, "value__", false, loc);
+ ec, decl_type, "value__", loc);
Enum en = TypeManager.LookupEnum (decl_type);
// a FieldExpr
//
- Expression ml = MemberLookup (ec, ec.TypeContainer.TypeBuilder, ee.EventInfo.Name,
- true, MemberTypes.Event, AllBindingFlags, loc);
+ Expression ml = MemberLookup (
+ ec, ec.TypeContainer.TypeBuilder,
+ ee.EventInfo.Name, MemberTypes.Event, AllBindingFlags, loc);
if (ml != null) {
MemberInfo mi = ec.TypeContainer.GetFieldFromEvent ((EventExpr) ml);
}
}
- member_lookup = MemberLookup (ec, expr_type, Identifier, false, loc);
+ member_lookup = MemberLookup (ec, expr_type, Identifier, loc);
if (member_lookup == null)
return null;
return ResolveMemberAccess (ec, member_lookup, expr, loc, original);
}
-#else
-
- bla bla bla
- //
- // This code is more conformant to the spec (it follows it step by step),
- // but it has not been tested yet, and there is nothing here that is not
- // caught by the above code. But it might be a better foundation to improve
- // on in the future
- //
- public ResolveTypeMemberAccess (EmitContext ec, Expression member_lookup,
- Expression left, Location loc)
- {
- if (member_lookup is TypeExpr){
- member_lookup.Resolve (ec);
- return member_lookup;
- }
-
- if (member_lookup is MethodGroupExpr){
- if (!mg.RemoveStaticMethods ()){
- SimpleName.Error120 (loc, mg.Methods [0].Name);
- return null;
- }
-
- return member_lookup;
- }
-
- if (member_lookup is PropertyExpr){
- PropertyExpr pe = (PropertyExpr) member_lookup;
-
- if (!pe.IsStatic){
- SimpleName.Error120 (loc, pe.PropertyInfo.Name);
- return null;
- }
- return pe;
- }
-
- if (member_lookup is FieldExpr){
- FieldExpr fe = (FieldExpr) member_lookup;
- FieldInfo fi = fe.FieldInfo;
-
- if (fi is FieldBuilder) {
- Const c = TypeManager.LookupConstant ((FieldBuilder) fi);
-
- if (c != null) {
- object o = c.LookupConstantValue (ec);
- return Constantify (o, fi.FieldType);
- }
- }
-
- if (fi.IsLiteral) {
- Type t = fi.FieldType;
- Type decl_type = fi.DeclaringType;
- object o;
-
- if (fi is FieldBuilder)
- o = TypeManager.GetValue ((FieldBuilder) fi);
- else
- o = fi.GetValue (fi);
-
- if (decl_type.IsSubclassOf (TypeManager.enum_type)) {
- Expression enum_member = MemberLookup (
- ec, decl_type, "value__",
- false, loc);
-
- Enum en = TypeManager.LookupEnum (decl_type);
-
- Constant c;
- if (en != null)
- c = Constantify (o, en.UnderlyingType);
- else
- c = Constantify (o, enum_member.Type);
-
- return new EnumConstant (c, decl_type);
- }
-
- Expression exp = Constantify (o, t);
-
- return exp;
- }
-
- if (!fe.FieldInfo.IsStatic){
- error176 (loc, fe.FieldInfo.Name);
- return null;
- }
- return member_lookup;
- }
-
- if (member_lookup is EventExpr){
-
- EventExpr ee = (EventExpr) member_lookup;
-
- //
- // If the event is local to this class, we transform ourselves into
- // a FieldExpr
- //
-
- Expression ml = MemberLookup (
- ec, ec.TypeContainer.TypeBuilder, ee.EventInfo.Name,
- true, MemberTypes.Event, AllBindingFlags, loc);
-
- if (ml != null) {
- MemberInfo mi = ec.TypeContainer.GetFieldFromEvent ((EventExpr) ml);
-
- ml = ExprClassFromMemberInfo (ec, mi, loc);
-
- if (ml == null) {
- Report.Error (-200, loc, "Internal error!!");
- return null;
- }
-
- return ResolveMemberAccess (ec, ml, left, loc);
- }
-
- if (!ee.IsStatic) {
- SimpleName.Error120 (loc, ee.EventInfo.Name);
- return null;
- }
-
- return ee;
- }
-
- Console.WriteLine ("Left is: " + left);
- Report.Error (-100, loc, "Support for [" + member_lookup + "] is not present yet");
- Environment.Exit (0);
-
- return null;
- }
-
- public ResolveInstanceMemberAccess (EmitContext ec, Expression member_lookup,
- Expression left, Location loc)
- {
- if (member_lookup is MethodGroupExpr){
- //
- // Instance.MethodGroup
- //
- if (!mg.RemoveStaticMethods ()){
- error176 (loc, mg.Methods [0].Name);
- return null;
- }
-
- mg.InstanceExpression = left;
-
- return member_lookup;
- }
-
- if (member_lookup is PropertyExpr){
- PropertyExpr pe = (PropertyExpr) member_lookup;
-
- if (pe.IsStatic){
- error176 (loc, pe.PropertyInfo.Name);
- return null;
- }
- pe.InstanceExpression = left;
-
- return pe;
- }
-
- Type left_type = left.type;
-
- if (left_type.IsValueType){
- } else {
-
- }
- }
-
- public override Expression DoResolve (EmitContext ec)
- {
- //
- // We are the sole users of ResolveWithSimpleName (ie, the only
- // ones that can cope with it
- //
- expr = expr.ResolveWithSimpleName (ec);
-
- if (expr == null)
- return null;
-
- if (expr is SimpleName){
- SimpleName child_expr = (SimpleName) expr;
-
- expr = new SimpleName (child_expr.Name + "." + Identifier, loc);
-
- return expr.ResolveWithSimpleName (ec);
- }
-
- //
- // Handle enums here when they are in transit.
- // Note that we cannot afford to hit MemberLookup in this case because
- // it will fail to find any members at all (Why?)
- //
-
- Type expr_type = expr.Type;
- if (expr_type.IsSubclassOf (TypeManager.enum_type)) {
-
- Enum en = TypeManager.LookupEnum (expr_type);
-
- if (en != null) {
- object value = en.LookupEnumValue (ec, Identifier, loc);
-
- if (value == null)
- return null;
-
- Constant c = Constantify (value, en.UnderlyingType);
- return new EnumConstant (c, expr_type);
- }
- }
-
- member_lookup = MemberLookup (ec, expr.Type, Identifier, false, loc);
-
- if (member_lookup == null)
- return null;
-
- if (expr is TypeExpr)
- return ResolveTypeMemberAccess (ec, member_lookup, expr, loc);
- else
- return ResolveInstanceMemberAccess (ec, member_lookup, expr, loc);
- }
-#endif
public override void Emit (EmitContext ec)
{
throw new Exception ("Should not happen");
Type base_type = current_type.BaseType;
Expression e;
- member_lookup = MemberLookup (ec, base_type, member, false, loc);
+ member_lookup = MemberLookup (ec, base_type, member, loc);
if (member_lookup == null)
return null;
Type base_type = current_type.BaseType;
Expression member_lookup;
- member_lookup = MemberLookup (ec, base_type, "get_Item", false, loc);
+ member_lookup = MemberLookup (ec, base_type, "get_Item", loc);
if (member_lookup == null)
return null;
EmitContext ec = new EmitContext (parent, loc, null, null, flags);
Expression ml = Expression.MemberLookup (ec, TypeManager.default_member_type,
- ".ctor", false, MemberTypes.Constructor,
+ ".ctor", MemberTypes.Constructor,
BindingFlags.Public | BindingFlags.Instance,
Location.Null);
--- /dev/null
+#else
+
+ bla bla bla
+ //
+ // This code is more conformant to the spec (it follows it step by step),
+ // but it has not been tested yet, and there is nothing here that is not
+ // caught by the above code. But it might be a better foundation to improve
+ // on in the future
+ //
+ public ResolveTypeMemberAccess (EmitContext ec, Expression member_lookup,
+ Expression left, Location loc)
+ {
+ if (member_lookup is TypeExpr){
+ member_lookup.Resolve (ec);
+ return member_lookup;
+ }
+
+ if (member_lookup is MethodGroupExpr){
+ if (!mg.RemoveStaticMethods ()){
+ SimpleName.Error120 (loc, mg.Methods [0].Name);
+ return null;
+ }
+
+ return member_lookup;
+ }
+
+ if (member_lookup is PropertyExpr){
+ PropertyExpr pe = (PropertyExpr) member_lookup;
+
+ if (!pe.IsStatic){
+ SimpleName.Error120 (loc, pe.PropertyInfo.Name);
+ return null;
+ }
+ return pe;
+ }
+
+ if (member_lookup is FieldExpr){
+ FieldExpr fe = (FieldExpr) member_lookup;
+ FieldInfo fi = fe.FieldInfo;
+
+ if (fi is FieldBuilder) {
+ Const c = TypeManager.LookupConstant ((FieldBuilder) fi);
+
+ if (c != null) {
+ object o = c.LookupConstantValue (ec);
+ return Constantify (o, fi.FieldType);
+ }
+ }
+
+ if (fi.IsLiteral) {
+ Type t = fi.FieldType;
+ Type decl_type = fi.DeclaringType;
+ object o;
+
+ if (fi is FieldBuilder)
+ o = TypeManager.GetValue ((FieldBuilder) fi);
+ else
+ o = fi.GetValue (fi);
+
+ if (decl_type.IsSubclassOf (TypeManager.enum_type)) {
+ Expression enum_member = MemberLookup (
+ ec, decl_type, "value__", loc);
+
+ Enum en = TypeManager.LookupEnum (decl_type);
+
+ Constant c;
+ if (en != null)
+ c = Constantify (o, en.UnderlyingType);
+ else
+ c = Constantify (o, enum_member.Type);
+
+ return new EnumConstant (c, decl_type);
+ }
+
+ Expression exp = Constantify (o, t);
+
+ return exp;
+ }
+
+ if (!fe.FieldInfo.IsStatic){
+ error176 (loc, fe.FieldInfo.Name);
+ return null;
+ }
+ return member_lookup;
+ }
+
+ if (member_lookup is EventExpr){
+
+ EventExpr ee = (EventExpr) member_lookup;
+
+ //
+ // If the event is local to this class, we transform ourselves into
+ // a FieldExpr
+ //
+
+ Expression ml = MemberLookup (
+ ec, ec.TypeContainer.TypeBuilder, ee.EventInfo.Name,
+ MemberTypes.Event, AllBindingFlags, loc);
+
+ if (ml != null) {
+ MemberInfo mi = ec.TypeContainer.GetFieldFromEvent ((EventExpr) ml);
+
+ ml = ExprClassFromMemberInfo (ec, mi, loc);
+
+ if (ml == null) {
+ Report.Error (-200, loc, "Internal error!!");
+ return null;
+ }
+
+ return ResolveMemberAccess (ec, ml, left, loc);
+ }
+
+ if (!ee.IsStatic) {
+ SimpleName.Error120 (loc, ee.EventInfo.Name);
+ return null;
+ }
+
+ return ee;
+ }
+
+ Console.WriteLine ("Left is: " + left);
+ Report.Error (-100, loc, "Support for [" + member_lookup + "] is not present yet");
+ Environment.Exit (0);
+
+ return null;
+ }
+
+ public ResolveInstanceMemberAccess (EmitContext ec, Expression member_lookup,
+ Expression left, Location loc)
+ {
+ if (member_lookup is MethodGroupExpr){
+ //
+ // Instance.MethodGroup
+ //
+ if (!mg.RemoveStaticMethods ()){
+ error176 (loc, mg.Methods [0].Name);
+ return null;
+ }
+
+ mg.InstanceExpression = left;
+
+ return member_lookup;
+ }
+
+ if (member_lookup is PropertyExpr){
+ PropertyExpr pe = (PropertyExpr) member_lookup;
+
+ if (pe.IsStatic){
+ error176 (loc, pe.PropertyInfo.Name);
+ return null;
+ }
+ pe.InstanceExpression = left;
+
+ return pe;
+ }
+
+ Type left_type = left.type;
+
+ if (left_type.IsValueType){
+ } else {
+
+ }
+ }
+
+ public override Expression DoResolve (EmitContext ec)
+ {
+ //
+ // We are the sole users of ResolveWithSimpleName (ie, the only
+ // ones that can cope with it
+ //
+ expr = expr.ResolveWithSimpleName (ec);
+
+ if (expr == null)
+ return null;
+
+ if (expr is SimpleName){
+ SimpleName child_expr = (SimpleName) expr;
+
+ expr = new SimpleName (child_expr.Name + "." + Identifier, loc);
+
+ return expr.ResolveWithSimpleName (ec);
+ }
+
+ //
+ // Handle enums here when they are in transit.
+ // Note that we cannot afford to hit MemberLookup in this case because
+ // it will fail to find any members at all (Why?)
+ //
+
+ Type expr_type = expr.Type;
+ if (expr_type.IsSubclassOf (TypeManager.enum_type)) {
+
+ Enum en = TypeManager.LookupEnum (expr_type);
+
+ if (en != null) {
+ object value = en.LookupEnumValue (ec, Identifier, loc);
+
+ if (value == null)
+ return null;
+
+ Constant c = Constantify (value, en.UnderlyingType);
+ return new EnumConstant (c, expr_type);
+ }
+ }
+
+ member_lookup = MemberLookup (ec, expr.Type, Identifier, loc);
+
+ if (member_lookup == null)
+ return null;
+
+ if (expr is TypeExpr)
+ return ResolveTypeMemberAccess (ec, member_lookup, expr, loc);
+ else
+ return ResolveInstanceMemberAccess (ec, member_lookup, expr, loc);
+ }
+#endif
projects / mono.git / commitdiff