2008-01-22 Miguel de Icaza <miguel@novell.com>

	* typemanager.cs (LinqExpression): renamed from
	ExpressionTreeManager, for a shorter name.

	Use TypeManager.CoreLookupType to lookup types from our core
	assemblies and turn those into "Type" variables.

	Consumers that previously used "Namespace" and "Type" from this
	class should instead use the TypeExpression which is a type that
	is fully resolved (without involving the regular C# resolution
	rules).

	This typically looks like this:

	TypeExpression texpr = new TypeExpression (LinqExpression.expression_type, loc);
	new MemberAccess (texpr, name, type_arguments, loc)

	This avoids the problem in: #355178

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

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 2850cd7fa4a925bb3102870759a269b8f847e3c1..cafb86fe47ff49a1e9b1d0d95f6f82d3fd0b77d7 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,23 @@
+2008-01-22  Miguel de Icaza  <miguel@novell.com>
+
+       * typemanager.cs (LinqExpression): renamed from
+       ExpressionTreeManager, for a shorter name.
+
+       Use TypeManager.CoreLookupType to lookup types from our core
+       assemblies and turn those into "Type" variables.
+
+       Consumers that previously used "Namespace" and "Type" from this
+       class should instead use the TypeExpression which is a type that
+       is fully resolved (without involving the regular C# resolution
+       rules). 
+
+       This typically looks like this:
+
+       TypeExpression texpr = new TypeExpression (LinqExpression.expression_type, loc);
+       new MemberAccess (texpr, name, type_arguments, loc)
+
+       This avoids the problem in: #355178
+
 2008-01-21  Marek Safar  <marek.safar@gmail.com>
 
        * cs-parser.jay, expression.cs: Check `namespace alias qualifier' language

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index 9cc6608586d17789eb1e42c4213a8ef29bc714bf..dc22c6b5da134a20d5327c5eea19437323711071 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -1254,9 +1254,8 @@ namespace Mono.CSharp {
 
                public static Expression CreateExpressionFactoryCall (string name, TypeArguments typeArguments, ArrayList args, Location loc)
                {
-                       return new Invocation (
-                               new MemberAccess (ExpressionTreeManager.Type, name, typeArguments, loc),
-                               args);
+                       TypeExpression texpr = new TypeExpression (LinqExpression.expression_type, loc);
+                       return new Invocation (new MemberAccess (texpr, name, typeArguments, loc), args);
                }
        }
 

diff --git a/mcs/mcs/parameter.cs b/mcs/mcs/parameter.cs
index d917963f0e823fdb98462179447b33ff38e6fd03..b5f545ece5d7dda9eacd12fef918200024623562 100644 (file)
--- a/mcs/mcs/parameter.cs
+++ b/mcs/mcs/parameter.cs
@@ -642,9 +642,9 @@ namespace Mono.CSharp {
                        if (parameter_expr_tree_type != null)
                                return parameter_expr_tree_type;
 
-                       MemberAccess ma = new MemberAccess (
-                               ExpressionTreeManager.Namespace, "ParameterExpression", location);
-                       parameter_expr_tree_type = ma.ResolveAsTypeTerminal (ec, false);
+                       parameter_expr_tree_type = new TypeExpression (LinqExpression.parameter_expression_type, location).
+                               ResolveAsTypeTerminal (ec, false);
+
                        return parameter_expr_tree_type;
                }
        }

diff --git a/mcs/mcs/typemanager.cs b/mcs/mcs/typemanager.cs
index 0cbd13f5451dfc448168735cc96907884e9aee56..9c9d331849947b021a1ed83a74aec7970308666e 100644 (file)
--- a/mcs/mcs/typemanager.cs
+++ b/mcs/mcs/typemanager.cs
@@ -3708,14 +3708,26 @@ public sealed class TypeHandle : IMemberContainer {
        //
        // Common expressions used by expression trees
        //
-       static class ExpressionTreeManager
+       static class LinqExpression
        {
-               public static MemberAccess Namespace = new MemberAccess (
-                       new MemberAccess (new SimpleName ("System", Location.Null), "Linq", Location.Null),
-                       "Expressions", Location.Null);
-                       
-               public static MemberAccess Type =
-                       new MemberAccess (Namespace, "Expression", Location.Null);
-       }
+               //
+               // These represent types thare are loaded from System.Core, similar
+               // in spirit to the TypeManger _type variables.
+               // 
+               public static Type expression_type;
+               public static Type parameter_expression_type;
 
+               //
+               // The expressions represeing the internal types, if used
+               //
+               public static TypeExpr expression_type_expr;
+               
+               static LinqExpression ()
+               {
+                       expression_type = TypeManager.CoreLookupType ("System.Linq.Expressions", "Expression");
+                       parameter_expression_type = TypeManager.CoreLookupType ("System.Linq.Expressions", "ParameterExpression");
+
+                       expression_type_expr = new TypeExpression (expression_type, Location.Null);
+               }
+       }
 }