Check expression type of resolved expressions too

diff --git a/mcs/errors/cs0075.cs b/mcs/errors/cs0075.cs
index a774362dfea122dd3bb6f89f0dfccbe73aa8c4db..367cfc7d579693d1bbbfde6238d3cdc87e27ce31 100644 (file)
--- a/mcs/errors/cs0075.cs
+++ b/mcs/errors/cs0075.cs
@@ -17,7 +17,7 @@ class X
        public static void Main ()
        {
                int a = 4, b = 5;
-               X x = (X) -a;
+X x = (X) -a;
                System.Console.WriteLine (x.i);
        }
 }

diff --git a/mcs/errors/cs0118-11.cs b/mcs/errors/cs0118-11.cs
old mode 100644 (file)
new mode 100755 (executable)
index df639d2..18d4263
--- a/mcs/errors/cs0118-11.cs
+++ b/mcs/errors/cs0118-11.cs
@@ -1,17 +1,10 @@
-// CS0118: `Test.SomeDel' is a `type' but a `variable' was expected
-// Line: 14
+// CS0118: `C' is a `type' but a `variable' was expected
+// Line: 8
 
-using System;
-
-namespace Test
+class C
 {
-       public delegate void SomeDel (Action a);
-
-       public class TestClass
+       public static void Main ()
        {
-               public void TestMethod ()
-               {
-                       SomeDel (() => { });
-               }
+               int i = (C) +1;
        }
-}
\ No newline at end of file
+}

diff --git a/mcs/errors/cs0118-12.cs b/mcs/errors/cs0118-12.cs
deleted file mode 100644 (file)
index c8d6203..0000000
--- a/mcs/errors/cs0118-12.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// CS0118: `A.Test' is a `type' but a `variable' was expected
-// Line: 10
-
-class A
-{
-       delegate string Test (string t);
-
-       public static void Main ()
-       {
-               Test ("t");
-       }
-}

diff --git a/mcs/errors/cs0119-2.cs b/mcs/errors/cs0119-2.cs
new file mode 100644 (file)
index 0000000..e3fc7da
--- /dev/null
+++ b/mcs/errors/cs0119-2.cs
@@ -0,0 +1,17 @@
+// CS0119: Expression denotes a `type', where a `variable', `value' or `method group' was expected
+// Line: 14
+
+using System;
+
+namespace Test
+{
+       public delegate void SomeDel (Action a);
+
+       public class TestClass
+       {
+               public void TestMethod ()
+               {
+                       SomeDel (() => { });
+               }
+       }
+}
\ No newline at end of file

diff --git a/mcs/errors/cs0119-8.cs b/mcs/errors/cs0119-8.cs
old mode 100755 (executable)
new mode 100644 (file)
index 2ee3844..7b7f14b
--- a/mcs/errors/cs0119-8.cs
+++ b/mcs/errors/cs0119-8.cs
@@ -1,10 +1,12 @@
 // CS0119: Expression denotes a `type', where a `variable', `value' or `method group' was expected
-// Line: 8
+// Line: 10
 
-class C
+class A
 {
+       delegate string Test (string t);
+
        public static void Main ()
        {
-               int i = (C) +1;
+               Test ("t");
        }
 }

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index b9e4f48c05228cebbb2c6b3ae0a10bcebf5134c0..a15f16ca2599b29652b15db152d1d13c0251e290 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -435,8 +435,14 @@ namespace Mono.CSharp {
                /// </remarks>
                public Expression Resolve (ResolveContext ec, ResolveFlags flags)
                {
-                       if (eclass != ExprClass.Unresolved)
+                       if (eclass != ExprClass.Unresolved) {
+                               if ((flags & ExprClassToResolveFlags) == 0) {
+                                       Error_UnexpectedKind (ec, flags, loc);
+                                       return null;
+                               }
+
                                return this;
+                       }
                        
                        Expression e;
                        try {
@@ -2452,7 +2458,7 @@ namespace Mono.CSharp {
 
                protected override Expression DoResolve (ResolveContext rc)
                {
-                       var e = SimpleNameResolve (rc, null, false);
+                       var e = SimpleNameResolve (rc, null);
 
                        var fe = e as FieldExpr;
                        if (fe != null) {
@@ -2464,7 +2470,7 @@ namespace Mono.CSharp {
 
                public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
                {
-                       return SimpleNameResolve (ec, right_side, false);
+                       return SimpleNameResolve (ec, right_side);
                }
 
                protected virtual void Error_TypeOrNamespaceNotFound (IMemberContext ctx)
@@ -2730,7 +2736,10 @@ namespace Mono.CSharp {
                                                        }
 
                                                        if (e is TypeExpr) {
-                                                               e.Error_UnexpectedKind (rc, e, "variable", e.ExprClassName, loc);
+                                                               // TypeExpression does not have correct location
+                                                               if (e is TypeExpression)
+                                                                       e = new TypeExpression (e.Type, loc);
+
                                                                return e;
                                                        }
                                                }
@@ -2752,19 +2761,19 @@ namespace Mono.CSharp {
                        }
                }
                
-               Expression SimpleNameResolve (ResolveContext ec, Expression right_side, bool intermediate)
+               Expression SimpleNameResolve (ResolveContext ec, Expression right_side)
                {
                        Expression e = LookupNameExpression (ec, right_side == null ? MemberLookupRestrictions.ReadAccess : MemberLookupRestrictions.None);
 
                        if (e == null)
                                return null;
 
-                       if (right_side != null) {
-                               if (e is FullNamedExpression && e.eclass != ExprClass.Unresolved) {
-                                       e.Error_UnexpectedKind (ec, e, "variable", e.ExprClassName, loc);
-                                   return null;
-                               }
+                       if (e is FullNamedExpression && e.eclass != ExprClass.Unresolved) {
+                               e.Error_UnexpectedKind (ec, e, "variable", e.ExprClassName, loc);
+                               return e;
+                       }
 
+                       if (right_side != null) {
                                e = e.ResolveLValue (ec, right_side);
                        } else {
                                e = e.Resolve (ec);
@@ -3660,7 +3669,7 @@ namespace Mono.CSharp {
                                                        InstanceExpression = ProbeIdenticalTypeName (ec, InstanceExpression, simple_name);
                                                }
 
-                                               InstanceExpression.Resolve (ec);
+                                               InstanceExpression.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup | ResolveFlags.Type);
                                        }
                                }
 
@@ -3734,7 +3743,7 @@ namespace Mono.CSharp {
                //
                public virtual MethodGroupExpr LookupExtensionMethod (ResolveContext rc)
                {
-                       if (InstanceExpression == null)
+                       if (InstanceExpression == null || InstanceExpression.eclass == ExprClass.Type)
                                return null;
 
                        InstanceExpression = InstanceExpression.Resolve (rc);

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 14776484844ffafb07da563b3be88b150e706349..ec75a09a7dcd7b8c01d1452fe278ea585f9eeffb 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -6015,7 +6015,7 @@ namespace Mono.CSharp
                                if (member_expr != null)
                                        member_expr = member_expr.Resolve (ec);
                        } else {
-                               member_expr = expr.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
+                               member_expr = expr.Resolve (ec);
                        }
 
                        if (member_expr == null)
@@ -8598,7 +8598,7 @@ namespace Mono.CSharp
 
                                e = e.ResolveLValue (rc, right_side);
                        } else {
-                               e = e.Resolve (rc, ResolveFlags.VariableOrValue | ResolveFlags.Type);
+                               e = e.Resolve (rc, ResolveFlags.VariableOrValue | ResolveFlags.Type | ResolveFlags.MethodGroup);
                        }
 
                        return e;