From 8d8a05805dae1ef9651003da0a0adf39724ad84f Mon Sep 17 00:00:00 2001 From: Miguel de Icaza Date: Fri, 11 Jan 2002 02:29:59 +0000 Subject: [PATCH] 2002-01-11 Miguel de Icaza * 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. svn path=/trunk/mcs/; revision=1952 --- mcs/mcs/ChangeLog | 12 ++ mcs/mcs/assign.cs | 5 +- mcs/mcs/attribute.cs | 17 +-- mcs/mcs/class.cs | 2 +- mcs/mcs/codegen.cs | 7 ++ mcs/mcs/delegate.cs | 24 ++-- mcs/mcs/ecore.cs | 67 +++++++---- mcs/mcs/expression.cs | 254 +++--------------------------------------- mcs/mcs/interface.cs | 2 +- mcs/mcs/old-code.cs | 216 +++++++++++++++++++++++++++++++++++ 10 files changed, 329 insertions(+), 277 deletions(-) create mode 100755 mcs/mcs/old-code.cs diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog index 299a5f8841b..b37888f5dec 100755 --- a/mcs/mcs/ChangeLog +++ b/mcs/mcs/ChangeLog @@ -1,3 +1,15 @@ +2002-01-11 Miguel de Icaza + + * 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 * typemanager.cs (IndexerPropertyName): If we have a TypeBuilder, use diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs index 002b123ddc8..b30d48d3ef8 100755 --- a/mcs/mcs/assign.cs +++ b/mcs/mcs/assign.cs @@ -168,8 +168,9 @@ namespace Mono.CSharp { 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) { // diff --git a/mcs/mcs/attribute.cs b/mcs/mcs/attribute.cs index 188c62d2c55..1e10cb1115c 100644 --- a/mcs/mcs/attribute.cs +++ b/mcs/mcs/attribute.cs @@ -136,7 +136,7 @@ namespace Mono.CSharp { ArrayList prop_infos = new ArrayList (); ArrayList field_values = new ArrayList (); ArrayList prop_values = new ArrayList (); - + for (i = 0; i < named_args.Count; i++) { DictionaryEntry de = (DictionaryEntry) named_args [i]; string member_name = (string) de.Key; @@ -147,7 +147,7 @@ namespace Mono.CSharp { return null; Expression member = Expression.MemberLookup ( - ec, Type, member_name, false, + ec, Type, member_name, MemberTypes.Field | MemberTypes.Property, BindingFlags.Public | BindingFlags.Instance, Location); @@ -206,7 +206,7 @@ namespace Mono.CSharp { } Expression mg = Expression.MemberLookup ( - ec, Type, ".ctor", false, MemberTypes.Constructor, + ec, Type, ".ctor", MemberTypes.Constructor, BindingFlags.Public | BindingFlags.Instance, Location); if (mg == null) { @@ -531,7 +531,7 @@ namespace Mono.CSharp { bool exact_spelling = false; bool set_last_err = false; string entry_point = null; - + for (int i = 0; i < named_args.Count; i++) { DictionaryEntry de = (DictionaryEntry) named_args [i]; @@ -542,10 +542,11 @@ namespace Mono.CSharp { if (!a.Resolve (ec, Location)) return null; - Expression member = Expression.MemberLookup (ec, Type, member_name, false, - MemberTypes.Field | MemberTypes.Property, - BindingFlags.Public | BindingFlags.Instance, - Location); + Expression member = Expression.MemberLookup ( + ec, Type, member_name, + MemberTypes.Field | MemberTypes.Property, + BindingFlags.Public | BindingFlags.Instance, + Location); if (member == null || !(member is FieldExpr)) { error617 (member_name); diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs index b83540fa3f6..1ea176ee2a5 100755 --- a/mcs/mcs/class.cs +++ b/mcs/mcs/class.cs @@ -2271,7 +2271,7 @@ namespace Mono.CSharp { t = ec.TypeContainer.TypeBuilder; parent_constructor_group = Expression.MemberLookup ( - ec, t, ".ctor", true, + ec, t, ".ctor", MemberTypes.Constructor, BindingFlags.Public | BindingFlags.Instance, location); diff --git a/mcs/mcs/codegen.cs b/mcs/mcs/codegen.cs index 7a8d9e6b4d8..153f605b89f 100755 --- a/mcs/mcs/codegen.cs +++ b/mcs/mcs/codegen.cs @@ -108,6 +108,12 @@ namespace Mono.CSharp { /// public Type ReturnType; + /// + /// Points to the Type (extracted from the TypeContainer) that + /// declares this body of code + /// + public Type ContainerType; + /// /// Whether this is generating code for a constructor /// @@ -164,6 +170,7 @@ namespace Mono.CSharp { ReturnType = return_type; IsConstructor = is_constructor; CurrentBlock = null; + ContainerType = parent.TypeBuilder; loc = l; if (ReturnType == TypeManager.void_type) diff --git a/mcs/mcs/delegate.cs b/mcs/mcs/delegate.cs index 989fa917525..a1716c5a8ae 100644 --- a/mcs/mcs/delegate.cs +++ b/mcs/mcs/delegate.cs @@ -247,7 +247,8 @@ namespace Mono.CSharp { { ParameterData pd = Invocation.GetParameterData (mb); - Expression ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc); + Expression ml = Expression.MemberLookup ( + ec, delegate_type, "Invoke", loc); if (!(ml is MethodGroupExpr)) { Report.Error (-100, loc, "Internal error : could not find Invoke method!"); @@ -307,7 +308,8 @@ namespace Mono.CSharp { else arg_count = args.Count; - Expression ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc); + Expression ml = Expression.MemberLookup ( + ec, delegate_type, "Invoke", loc); if (!(ml is MethodGroupExpr)) { Report.Error (-100, loc, "Internal error : could not find Invoke method!"); @@ -362,7 +364,8 @@ namespace Mono.CSharp { /// public static bool VerifyDelegate (EmitContext ec, Type delegate_type, Type probe_type, Location loc) { - Expression ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc); + Expression ml = Expression.MemberLookup ( + ec, delegate_type, "Invoke", loc); if (!(ml is MethodGroupExpr)) { Report.Error (-100, loc, "Internal error : could not find Invoke method!"); @@ -372,7 +375,8 @@ namespace Mono.CSharp { MethodBase mb = ((MethodGroupExpr) ml).Methods [0]; ParameterData pd = Invocation.GetParameterData (mb); - Expression probe_ml = Expression.MemberLookup (ec, delegate_type, "Invoke", false, loc); + Expression probe_ml = Expression.MemberLookup ( + ec, delegate_type, "Invoke", loc); if (!(probe_ml is MethodGroupExpr)) { Report.Error (-100, loc, "Internal error : could not find Invoke method!"); @@ -519,7 +523,8 @@ namespace Mono.CSharp { return null; } - Expression ml = Expression.MemberLookup (ec, type, ".ctor", false, Location); + Expression ml = Expression.MemberLookup ( + ec, type, ".ctor", Location); if (!(ml is MethodGroupExpr)) { Report.Error (-100, Location, "Internal error : Could not find delegate constructor!"); @@ -582,10 +587,9 @@ namespace Mono.CSharp { return null; } - Expression invoke_method = Expression.MemberLookup (ec, e_type, "Invoke", false, - MemberTypes.Method, - Expression.AllBindingFlags, - Location); + Expression invoke_method = Expression.MemberLookup ( + ec, e_type, "Invoke", MemberTypes.Method, + Expression.AllBindingFlags, Location); if (invoke_method == null) { Report.Error (-200, Location, "Internal error ! COuld not find Invoke method!"); @@ -646,7 +650,7 @@ namespace Mono.CSharp { if (!Delegate.VerifyApplicability (ec, del_type, Arguments, Location)) return null; - Expression ml = Expression.MemberLookup (ec, del_type, "Invoke", false, Location); + Expression ml = Expression.MemberLookup (ec, del_type, "Invoke", Location); if (!(ml is MethodGroupExpr)) { Report.Error (-100, Location, "Internal error : could not find Invoke method!"); diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs index c83a7372356..c0bf5f2dce2 100755 --- a/mcs/mcs/ecore.cs +++ b/mcs/mcs/ecore.cs @@ -368,9 +368,6 @@ namespace Mono.CSharp { // // 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 @@ -395,11 +392,13 @@ namespace Mono.CSharp { // // 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; // @@ -473,12 +472,42 @@ namespace Mono.CSharp { 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); } + /// + /// 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. + /// + 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; @@ -1024,15 +1053,15 @@ namespace Mono.CSharp { 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); @@ -1045,15 +1074,15 @@ namespace Mono.CSharp { 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); @@ -2712,7 +2741,7 @@ namespace Mono.CSharp { // // 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. @@ -2793,7 +2822,7 @@ namespace Mono.CSharp { 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); diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs index 1540986626f..89955a2a79b 100755 --- a/mcs/mcs/expression.cs +++ b/mcs/mcs/expression.cs @@ -263,10 +263,10 @@ namespace Mono.CSharp { 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 ( @@ -562,10 +562,10 @@ namespace Mono.CSharp { 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 ( @@ -1462,13 +1462,13 @@ namespace Mono.CSharp { 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); @@ -3220,7 +3220,7 @@ namespace Mono.CSharp { // if (expr is BaseAccess) is_base = true; - + expr = expr.Resolve (ec); if (expr == null) return null; @@ -3507,8 +3507,7 @@ namespace Mono.CSharp { 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){ @@ -3883,7 +3882,7 @@ namespace Mono.CSharp { Expression ml; - ml = MemberLookup (ec, type, ".ctor", false, MemberTypes.Constructor, + ml = MemberLookup (ec, type, ".ctor", MemberTypes.Constructor, AllBindingFlags, loc); if (!(ml is MethodGroupExpr)){ @@ -4394,7 +4393,6 @@ namespace Mono.CSharp { "type name instead"); } -#if USE_OLD static bool IdenticalNameAndTypeName (EmitContext ec, Expression left_original, Location loc) { if (left_original == null) @@ -4481,7 +4479,7 @@ namespace Mono.CSharp { 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); @@ -4556,8 +4554,9 @@ namespace Mono.CSharp { // 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); @@ -4656,7 +4655,7 @@ namespace Mono.CSharp { } } - member_lookup = MemberLookup (ec, expr_type, Identifier, false, loc); + member_lookup = MemberLookup (ec, expr_type, Identifier, loc); if (member_lookup == null) return null; @@ -4664,223 +4663,6 @@ namespace Mono.CSharp { 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"); @@ -5451,7 +5233,7 @@ namespace Mono.CSharp { 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; @@ -5497,7 +5279,7 @@ namespace Mono.CSharp { 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; diff --git a/mcs/mcs/interface.cs b/mcs/mcs/interface.cs index de489332abc..2ba3b0eee66 100755 --- a/mcs/mcs/interface.cs +++ b/mcs/mcs/interface.cs @@ -690,7 +690,7 @@ namespace Mono.CSharp { 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); diff --git a/mcs/mcs/old-code.cs b/mcs/mcs/old-code.cs new file mode 100755 index 00000000000..271ffa2a7f5 --- /dev/null +++ b/mcs/mcs/old-code.cs @@ -0,0 +1,216 @@ +#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 -- 2.25.1