2004-11-18 Martin Baulig <martin@ximian.com>

	* ecore.cs (TypeExpr.ResolveType): Removed.
	(Expression.ResolveAsTypeTerminal): We always return a fully
	resolved `TypeExpr', so we can just access its `Type'.

	* class.cs (TypeContainer.DefineType): Resolve `CurrentType' here.

svn path=/trunk/mcs/; revision=36242

diff --git a/mcs/gmcs/ChangeLog b/mcs/gmcs/ChangeLog
index fac75cad0a616cc7741ead271febb00236f19e40..6974697861f27102848401b4e2fb59e82f51399b 100755 (executable)
--- a/mcs/gmcs/ChangeLog
+++ b/mcs/gmcs/ChangeLog
@@ -1,3 +1,11 @@
+2004-11-18  Martin Baulig  <martin@ximian.com>
+
+       * ecore.cs (TypeExpr.ResolveType): Removed.
+       (Expression.ResolveAsTypeTerminal): We always return a fully
+       resolved `TypeExpr', so we can just access its `Type'.
+
+       * class.cs (TypeContainer.DefineType): Resolve `CurrentType' here.
+
 2004-11-17  Martin Baulig  <martin@ximian.com>
 
        * ecore.cs (IAlias.Type): Replaced with ResolveAsType() to make

diff --git a/mcs/gmcs/attribute.cs b/mcs/gmcs/attribute.cs
index 17fef886ef9241d9a44bf315f4789e5ee9069ccd..e237f6e11aec3e3b45b35c9ff9af5bedc450bf9c 100644 (file)
--- a/mcs/gmcs/attribute.cs
+++ b/mcs/gmcs/attribute.cs
@@ -179,9 +179,9 @@ namespace Mono.CSharp {
                                return null;
                        }
                        if (t1 != null)
-                               return t1.ResolveType (ec);
+                               return t1.Type;
                        if (t2 != null)
-                               return t2.ResolveType (ec);
+                               return t2.Type;
                        if (err0616 != null) {
                                Report.Error (616, Location, err0616);
                                return null;

diff --git a/mcs/gmcs/class.cs b/mcs/gmcs/class.cs
index ba16c3c8cc83719a921aaa9b35b6a6ce070e7467..5d1606ac7df079b5464f5f4a0cbabaed85db6656 100755 (executable)
--- a/mcs/gmcs/class.cs
+++ b/mcs/gmcs/class.cs
@@ -1212,6 +1212,8 @@ namespace Mono.CSharp {
 
                        TypeManager.AddUserType (Name, TypeBuilder, this);
 
+                       TypeExpr current_type = null;
+
                        if (IsGeneric) {
                                string[] param_names = new string [TypeParameters.Length];
                                for (int i = 0; i < TypeParameters.Length; i++)
@@ -1234,7 +1236,7 @@ namespace Mono.CSharp {
                                for (int i = offset; i < gen_params.Length; i++)
                                        CurrentTypeParameters [i - offset].DefineConstraints ();
 
-                               CurrentType = new ConstructedType (Name, TypeParameters, Location);
+                               current_type = new ConstructedType (Name, TypeParameters, Location);
                        }
 
                        if (IsGeneric) {
@@ -1271,18 +1273,14 @@ namespace Mono.CSharp {
                                }
                        }
 
-                       ConstructedType constructed = parent_type as ConstructedType;
-                       if ((constructed == null) && (parent_type != null))
-                               ptype = parent_type.ResolveType (ec);
-                       else
-                               ptype = null;
-
-                       if (constructed != null) {
-                               ptype = constructed.ResolveType (ec);
-                               if (ptype == null) {
+                       if (parent_type != null) {
+                               parent_type = parent_type.ResolveAsTypeTerminal (ec);
+                               if (parent_type == null) {
                                        error = true;
                                        return null;
                                }
+
+                               ptype = parent_type.Type;
                        }
 
                        if (!CheckRecursiveDefinition ()) {
@@ -1332,6 +1330,14 @@ namespace Mono.CSharp {
                                        }
                        }
 
+                       if (current_type != null) {
+                               CurrentType = current_type.ResolveAsTypeTerminal (ec);
+                               if (CurrentType == null) {
+                                       error = true;
+                                       return null;
+                               }
+                       }
+
                        //
                        // Finish the setup for the EmitContext
                        //
@@ -1523,7 +1529,7 @@ namespace Mono.CSharp {
                        DefineContainerMembers (delegates);
 
                        if (CurrentType != null) {
-                               GenericType = CurrentType.ResolveType (ec);
+                               GenericType = CurrentType.Type;
 
                                ec.ContainerType = GenericType;
                        }
@@ -4855,7 +4861,7 @@ namespace Mono.CSharp {
                                return false;
 
                        if (container.CurrentType != null)
-                               declaring_type = container.CurrentType.ResolveType (ec);
+                               declaring_type = container.CurrentType.Type;
                        else
                                declaring_type = container.TypeBuilder;
 
@@ -5239,9 +5245,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return false;
 
-                       MemberType = texpr.ResolveType (ec);
-                       if (MemberType == null)
-                               return false;
+                       MemberType = texpr.Type;
 
                        if ((Parent.ModFlags & Modifiers.SEALED) != 0){
                                if ((ModFlags & (Modifiers.VIRTUAL|Modifiers.ABSTRACT)) != 0){
@@ -5290,9 +5294,7 @@ namespace Mono.CSharp {
                                if (iface_texpr == null)
                                        return false;
 
-                               InterfaceType = iface_texpr.ResolveType (ec);
-                               if (InterfaceType == null)
-                                       return false;
+                               InterfaceType = iface_texpr.Type;
 
                                if (InterfaceType.IsClass) {
                                        Report.Error (538, Location, "'{0}' in explicit interface declaration is not an interface", ExplicitInterfaceName);
@@ -5561,13 +5563,11 @@ namespace Mono.CSharp {
                        bool old_unsafe = ec.InUnsafe;
                        ec.InUnsafe = InUnsafe;
                        TypeExpr texpr = Type.ResolveAsTypeTerminal (ec);
+                       ec.InUnsafe = old_unsafe;
                        if (texpr == null)
                                return false;
                        
-                       MemberType = texpr.ResolveType (ec);
-                       ec.InUnsafe = old_unsafe;
-                       if (MemberType == null)
-                               return false;
+                       MemberType = texpr.Type;
 
                        if (!CheckBase ())
                                return false;

diff --git a/mcs/gmcs/decl.cs b/mcs/gmcs/decl.cs
index c59366f9551d95cd4b02bf8b7f9926acbf05de70..d75008c735059e087edfc8cc588457ede3da4805 100755 (executable)
--- a/mcs/gmcs/decl.cs
+++ b/mcs/gmcs/decl.cs
@@ -687,8 +687,12 @@ namespace Mono.CSharp {
                                else
                                        args = TypeParameters;
 
-                               ConstructedType ctype = new ConstructedType (t, args, loc);
-                               t = ctype.ResolveType (ec);
+                               TypeExpr ctype = new ConstructedType (t, args, loc);
+                               ctype = ctype.ResolveAsTypeTerminal (ec);
+                               if (ctype == null)
+                                       return null;
+
+                               t = ctype.Type;
                        }
 
                        return t;

diff --git a/mcs/gmcs/ecore.cs b/mcs/gmcs/ecore.cs
index 4f0273134ac996322e8818622a370d410ef747e0..32c54bdc378482cd58c10ad27c92800d4aa6a34d 100755 (executable)
--- a/mcs/gmcs/ecore.cs
+++ b/mcs/gmcs/ecore.cs
@@ -2375,15 +2375,6 @@ namespace Mono.CSharp {
 
                public abstract TypeExpr DoResolveAsTypeStep (EmitContext ec);
 
-               public Type ResolveType (EmitContext ec)
-               {
-                       TypeExpr t = ResolveAsTypeTerminal (ec);
-                       if (t == null)
-                               return null;
-
-                       return t.Type;
-               }
-
                public abstract string Name {
                        get;
                }
@@ -2464,9 +2455,11 @@ namespace Mono.CSharp {
                                if (texpr == null)
                                        return null;
 
-                               type = texpr.ResolveType (ec);
-                               if (type == null)
+                               texpr = texpr.ResolveAsTypeTerminal (ec);
+                               if (texpr == null)
                                        return null;
+
+                               type = texpr.Type;
                        }
 
                        return this;
@@ -2518,10 +2511,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return null;
 
-                       Type type = texpr.ResolveType (ec);
-                       if (type == null)
-                               return null;
-
+                       Type type = texpr.Type;
                        int num_args = TypeManager.GetNumberOfTypeArguments (type);
 
                        if (args != null) {
@@ -2996,7 +2986,7 @@ namespace Mono.CSharp {
                                Type ctype;
                                if (!is_field_initializer &&
                                    (ec.TypeContainer.CurrentType != null))
-                                       ctype = ec.TypeContainer.CurrentType.ResolveType (ec);
+                                       ctype = ec.TypeContainer.CurrentType.Type;
                                else
                                        ctype = ec.ContainerType;
 

diff --git a/mcs/gmcs/expression.cs b/mcs/gmcs/expression.cs
index 7b26d36516adb28b91c556e7bb87cbf49d37e306..7aa3237924bd07d6383fae79f31987b58f5381a0 100755 (executable)
--- a/mcs/gmcs/expression.cs
+++ b/mcs/gmcs/expression.cs
@@ -1034,7 +1034,7 @@ namespace Mono.CSharp {
                        TypeExpr texpr = ProbeType.ResolveAsTypeTerminal (ec);
                        if (texpr == null)
                                return null;
-                       probe_type = texpr.ResolveType (ec);
+                       probe_type = texpr.Type;
 
                        CheckObsoleteAttribute (probe_type);
 
@@ -1772,7 +1772,7 @@ namespace Mono.CSharp {
                        if (target == null)
                                return null;
                        
-                       type = target.ResolveType (ec);
+                       type = target.Type;
 
                        CheckObsoleteAttribute (type);
 
@@ -6003,7 +6003,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return null;
                        
-                       type = texpr.ResolveType (ec);
+                       type = texpr.Type;
                        if (type == null)
                                return null;
                        
@@ -6540,7 +6540,7 @@ namespace Mono.CSharp {
                        if (array_type_expr == null)
                                return false;
 
-                       type = array_type_expr.ResolveType (ec);
+                       type = array_type_expr.Type;
 
                        if (!type.IsArray) {
                                Error (622, "Can only use array initializer expressions to assign to array types. Try using a new expression instead.");
@@ -7040,7 +7040,7 @@ namespace Mono.CSharp {
                        eclass = ExprClass.Variable;
 
                        if (ec.TypeContainer.CurrentType != null)
-                               type = ec.TypeContainer.CurrentType.ResolveType (ec);
+                               type = ec.TypeContainer.CurrentType.Type;
                        else
                                type = ec.ContainerType;
 
@@ -7259,7 +7259,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return null;
 
-                       typearg = texpr.ResolveType (ec);
+                       typearg = texpr.Type;
 
                        if (typearg == TypeManager.void_type) {
                                Error (673, "System.Void cannot be used from C# - " +
@@ -7338,7 +7338,7 @@ namespace Mono.CSharp {
                                return null;
                        }
 
-                       type_queried = texpr.ResolveType (ec);
+                       type_queried = texpr.Type;
 
                        CheckObsoleteAttribute (type_queried);
 
@@ -7639,7 +7639,7 @@ namespace Mono.CSharp {
 
                        Type expr_type;
                        if (expr is TypeExpr){
-                               expr_type = ((TypeExpr) expr).ResolveType (ec);
+                               expr_type = expr.Type;
 
                                if (!ec.DeclSpace.CheckAccessLevel (expr_type)){
                                        Report.Error (122, loc, "'{0}' is inaccessible due to its protection level", expr_type);
@@ -7809,10 +7809,12 @@ namespace Mono.CSharp {
                                return new_expr.ResolveAsTypeStep (ec);
                        }
 
-                       Type expr_type = ((TypeExpr) new_expr).ResolveType (ec);
-                       if (expr_type == null)
+                       TypeExpr tnew_expr = new_expr.ResolveAsTypeTerminal (ec);
+                       if (tnew_expr == null)
                                return null;
 
+                       Type expr_type = tnew_expr.Type;
+
                        if (expr_type.IsPointer){
                                Error (23, "The `.' operator can not be applied to pointer operands (" +
                                       TypeManager.CSharpName (expr_type) + ")");
@@ -7831,8 +7833,8 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return null;
 
-                       Type t = texpr.ResolveType (ec);
-                       if (t == null)
+                       texpr = texpr.ResolveAsTypeTerminal (ec);
+                       if (texpr == null)
                                return null;
 
                        TypeArguments the_args = args;
@@ -7850,7 +7852,7 @@ namespace Mono.CSharp {
                        }
 
                        if (the_args != null) {
-                               ConstructedType ctype = new ConstructedType (t, the_args, loc);
+                               ConstructedType ctype = new ConstructedType (texpr.Type, the_args, loc);
                                return ctype.ResolveAsTypeStep (ec);
                        }
 
@@ -8985,7 +8987,7 @@ namespace Mono.CSharp {
                        if (lexpr == null)
                                return null;
 
-                       Type ltype = lexpr.ResolveType (ec);
+                       Type ltype = lexpr.Type;
 
                        if ((ltype == TypeManager.void_type) && (dim != "*")) {
                                Report.Error (1547, Location,
@@ -9042,9 +9044,11 @@ namespace Mono.CSharp {
                                if (texpr == null)
                                        return null;
 
-                               type = texpr.ResolveType (ec);
-                               if (type == null)
+                               texpr = texpr.ResolveAsTypeTerminal (ec);
+                               if (texpr == null)
                                        return null;
+
+                               type = texpr.Type;
                        }
 
                        if (!ec.InUnsafe && type.IsPointer){
@@ -9176,9 +9180,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return null;
 
-                       otype = texpr.ResolveType (ec);
-                       if (otype == null)
-                               return null;
+                       otype = texpr.Type;
 
                        if (!TypeManager.VerifyUnManaged (otype, loc))
                                return null;

diff --git a/mcs/gmcs/generic.cs b/mcs/gmcs/generic.cs
index 0720906b141f82ce771ef12a67b85c39e3342eff..95aa1808111ab5bfb8175db5f5a4ffdf993be02d 100644 (file)
--- a/mcs/gmcs/generic.cs
+++ b/mcs/gmcs/generic.cs
@@ -269,46 +269,39 @@ namespace Mono.CSharp {
                        ArrayList list = new ArrayList ();
 
                        foreach (TypeExpr iface_constraint in iface_constraints) {
-                               Type resolved = iface_constraint.ResolveType (ec);
-                               if (resolved == null)
-                                       return false;
-
                                foreach (Type type in list) {
-                                       if (!type.Equals (resolved))
+                                       if (!type.Equals (iface_constraint.Type))
                                                continue;
 
                                        Report.Error (405, loc,
                                                      "Duplicate constraint `{0}' for type " +
-                                                     "parameter `{1}'.", resolved, name);
+                                                     "parameter `{1}'.", iface_constraint.Type,
+                                                     name);
                                        return false;
                                }
 
-                               list.Add (resolved);
+                               list.Add (iface_constraint.Type);
                        }
 
                        foreach (TypeParameterExpr expr in type_param_constraints) {
-                               Type resolved = expr.ResolveType (ec);
-                               if (resolved == null)
-                                       return false;
-
                                foreach (Type type in list) {
-                                       if (!type.Equals (resolved))
+                                       if (!type.Equals (expr.Type))
                                                continue;
 
                                        Report.Error (405, loc,
                                                      "Duplicate constraint `{0}' for type " +
-                                                     "parameter `{1}'.", resolved, name);
+                                                     "parameter `{1}'.", expr.Type, name);
                                        return false;
                                }
 
-                               list.Add (resolved);
+                               list.Add (expr.Type);
                        }
 
                        iface_constraint_types = new Type [list.Count];
                        list.CopyTo (iface_constraint_types, 0);
 
                        if (class_constraint != null) {
-                               class_constraint_type = class_constraint.ResolveType (ec);
+                               class_constraint_type = class_constraint.Type;
                                if (class_constraint_type == null)
                                        return false;
 
@@ -961,13 +954,8 @@ namespace Mono.CSharp {
                                }
                                if (te is TypeParameterExpr)
                                        has_type_args = true;
-                               atypes [i] = te.ResolveType (ec);
 
-                               if (atypes [i] == null) {
-                                       Report.Error (246, Location, "Cannot find type `{0}'",
-                                                     te.Name);
-                                       ok = false;
-                               }
+                               atypes [i] = te.Type;
                        }
                        return ok;
                }
@@ -1072,9 +1060,10 @@ namespace Mono.CSharp {
                                        new_args.Add (new TypeExpression (t, loc));
                                }
 
-                               ctype = new ConstructedType (ctype, new_args, loc).ResolveType (ec);
-                               if (ctype == null)
+                               TypeExpr ct = new ConstructedType (ctype, new_args, loc);
+                               if (ct.ResolveAsTypeTerminal (ec) == null)
                                        return false;
+                               ctype = ct.Type;
                        }
 
                        return Convert.ImplicitStandardConversionExists (ec, expr, ctype);
@@ -1424,10 +1413,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return null;
 
-                       type = texpr.ResolveType (ec);
-                       if (type == null)
-                               return null;
-
+                       type = texpr.Type;
                        if (type.IsGenericParameter || TypeManager.IsValueType (type))
                                temp_storage = new LocalTemporary (ec, type);
 

diff --git a/mcs/gmcs/iterators.cs b/mcs/gmcs/iterators.cs
index 529d67351ac2a68e2ace96224a8fd50987bdee81..b05639d8b7c802cc78cd45543e0d79376b64e3b3 100644 (file)
--- a/mcs/gmcs/iterators.cs
+++ b/mcs/gmcs/iterators.cs
@@ -399,7 +399,7 @@ namespace Mono.CSharp {
                        }
 
                        if (container.CurrentType != null)
-                               this_type = container.CurrentType.ResolveType (ec);
+                               this_type = container.CurrentType.Type;
                        else
                                this_type = container.TypeBuilder;
 

diff --git a/mcs/gmcs/parameter.cs b/mcs/gmcs/parameter.cs
index 29073a77a70e42a5122696a61e7fd18697ef69ae..67ef30ef01460541d2f60ba5bd79aa903cf2c57d 100755 (executable)
--- a/mcs/gmcs/parameter.cs
+++ b/mcs/gmcs/parameter.cs
@@ -175,7 +175,7 @@ namespace Mono.CSharp {
                        if (tparam != null)
                                constraints = tparam.TypeParameter.Constraints;
 
-                       parameter_type = texpr.ResolveType (ec);
+                       parameter_type = texpr.Type;
 
                        if (parameter_type.IsAbstract && parameter_type.IsSealed) {
                                Report.Error (721, l, "'{0}': static types cannot be used as parameters", GetSignatureForError ());

diff --git a/mcs/gmcs/statement.cs b/mcs/gmcs/statement.cs
index 4e50603945163cbef41ca2cdf3870c722742b13b..ca011abcb7dd46fb2276ec1e5f2672b269f2418d 100755 (executable)
--- a/mcs/gmcs/statement.cs
+++ b/mcs/gmcs/statement.cs
@@ -1027,9 +1027,7 @@ namespace Mono.CSharp {
                                if (texpr == null)
                                        return false;
                                
-                               VariableType = texpr.ResolveType (ec);
-                       if (VariableType == null)
-                                       return false;
+                               VariableType = texpr.Type;
                        }
 
                        if (VariableType == TypeManager.void_type) {
@@ -3293,7 +3291,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return false;
 
-                       expr_type = texpr.ResolveType (ec);
+                       expr_type = texpr.Type;
 
                        CheckObsolete (expr_type);
 
@@ -3562,7 +3560,7 @@ namespace Mono.CSharp {
                                if (te == null)
                                        return false;
 
-                               type = te.ResolveType (ec);
+                               type = te.Type;
 
                                CheckObsolete (type);
 
@@ -3768,7 +3766,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return false;
 
-                       expr_type = texpr.ResolveType (ec);
+                       expr_type = texpr.Type;
 
                        //
                        // The type must be an IDisposable or an implicit conversion
@@ -4043,7 +4041,7 @@ namespace Mono.CSharp {
                        if (texpr == null)
                                return false;
                        
-                       var_type = texpr.ResolveType (ec);
+                       var_type = texpr.Type;
 
                        //
                        // We need an instance variable.  Not sure this is the best

diff --git a/mcs/gmcs/typemanager.cs b/mcs/gmcs/typemanager.cs
index 3d0913d8ccf2f6aa11ee23e486032657a1e734f0..8f3f9b6020ac2b16a1c234e2338ed66607c8cc04 100755 (executable)
--- a/mcs/gmcs/typemanager.cs
+++ b/mcs/gmcs/typemanager.cs
@@ -2406,14 +2406,14 @@ public class TypeManager {
                ArrayList new_ifaces = new ArrayList ();
                
                foreach (TypeExpr iface in base_interfaces){
-                       Type itype = iface.ResolveType (ec);
-                       if (itype == null)
+                       TypeExpr texpr = iface.ResolveAsTypeTerminal (ec);
+                       if (texpr == null)
                                return null;
 
-                       if (!new_ifaces.Contains (itype))
-                               new_ifaces.Add (itype);
+                       if (!new_ifaces.Contains (texpr.Type))
+                               new_ifaces.Add (texpr.Type);
                        
-                       Type [] implementing = itype.GetInterfaces ();
+                       Type [] implementing = texpr.Type.GetInterfaces ();
                        
                        foreach (Type imp in implementing){
                                if (!new_ifaces.Contains (imp))