2009-11-19 Marek Safar <marek.safar@gmail.com>

	* *.cs: DoResolve is a worker method and has to be protected.

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

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index a4f1a460a56228087b4133341dad2a2741cc0696..306abb4f4f874930eb9c8c62e94107ecd81dabac 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,7 @@
+2009-11-19  Marek Safar  <marek.safar@gmail.com>
+
+       * *.cs: DoResolve is a worker method and has to be protected.
+
 2009-11-18  Marek Safar  <marek.safar@gmail.com>
 
        * *.cs: More context specific handling.

diff --git a/mcs/mcs/anonymous.cs b/mcs/mcs/anonymous.cs
index 49c22bd912734cb1cb83efa32fed2a28ca0c9d2b..7d69bd1ac8292c202c7e56379faee0ca20706d73 100644 (file)
--- a/mcs/mcs/anonymous.cs
+++ b/mcs/mcs/anonymous.cs
@@ -631,7 +631,7 @@ namespace Mono.CSharp {
                                throw new NotSupportedException ("ET");
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                eclass = ExprClass.Value;
                                type = TypeManager.expression_type_expr.Type;
@@ -854,8 +854,13 @@ namespace Mono.CSharp {
                                return CreateExpressionFactoryCall (ec, "Quote", args);
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext rc)
                        {
+                               expr = expr.Resolve (rc);
+                               if (expr == null)
+                                       return null;
+
+                               eclass = expr.eclass;
                                type = expr.Type;
                                return this;
                        }
@@ -1169,7 +1174,7 @@ namespace Mono.CSharp {
                        return Parameters;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (ec.HasSet (ResolveContext.Options.ConstantScope)) {
                                ec.Report.Error (1706, loc, "Anonymous methods and lambda expressions cannot be used in the current context");
@@ -1533,7 +1538,7 @@ namespace Mono.CSharp {
                                real_name, member_name, parameters);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass == ExprClass.Invalid) {
                                if (!Define (ec))

diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs
index 2b64ff4cbf7bc2672f62e960839b6ecf3703c013..a9faebde73a0cbe1b5fb4533523a3e85db4259d1 100644 (file)
--- a/mcs/mcs/assign.cs
+++ b/mcs/mcs/assign.cs
@@ -213,7 +213,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Constant", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }
@@ -332,7 +332,7 @@ namespace Mono.CSharp {
                        get { return source; }
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        bool ok = true;
                        source = source.Resolve (ec);
@@ -461,7 +461,7 @@ namespace Mono.CSharp {
                        return t.Equals (source);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        Expression e = base.DoResolve (ec);
                        if (e == null || e != this)
@@ -491,7 +491,7 @@ namespace Mono.CSharp {
                                ((FieldExpr)target).InstanceExpression = CompilerGeneratedThis.Instance;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // Field initializer can be resolved (fail) many times
                        if (source == null)
@@ -561,7 +561,7 @@ namespace Mono.CSharp {
                        return new SimpleAssign (target, source).CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (op != Binary.Operator.Addition && op != Binary.Operator.Subtraction)
                                target.Error_AssignmentEventOnly (ec);
@@ -613,7 +613,7 @@ namespace Mono.CSharp {
                                throw new NotSupportedException ("ET");
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                type = child.Type;
                                eclass = ExprClass.Value;
@@ -644,7 +644,7 @@ namespace Mono.CSharp {
                        this.left = left;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        right = right.Resolve (ec);
                        if (right == null)
@@ -666,7 +666,7 @@ namespace Mono.CSharp {
                        }
 
                        if (target is EventExpr)
-                               return new EventAddOrRemove (target, op, right, loc).DoResolve (ec);
+                               return new EventAddOrRemove (target, op, right, loc).Resolve (ec);
 
                        //
                        // Only now we can decouple the original source/target

diff --git a/mcs/mcs/attribute.cs b/mcs/mcs/attribute.cs
index 559f17b8ebc800761080e53a5cd1d4b9d0f291b8..be717d3197521242774e28293a663a695c135ccf 100644 (file)
--- a/mcs/mcs/attribute.cs
+++ b/mcs/mcs/attribute.cs
@@ -1281,7 +1281,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        throw new NotImplementedException ();
                }

diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs
index de13f8d4d6a040957fed3a905cf3f3fcacac8cac..2fcb856dd59451b129048f31b962d63a261b8955 100644 (file)
--- a/mcs/mcs/class.cs
+++ b/mcs/mcs/class.cs
@@ -4505,7 +4505,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        eclass = ExprClass.Value;
 

diff --git a/mcs/mcs/complete.cs b/mcs/mcs/complete.cs
index 2435d5a18f687773b75b28aa4694c04da08ff7ce..0c2bf2b4c88b258000c8efe5229bcf05a2871e3d 100644 (file)
--- a/mcs/mcs/complete.cs
+++ b/mcs/mcs/complete.cs
@@ -70,7 +70,7 @@ namespace Mono.CSharp {
 
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        ArrayList results = new ArrayList ();
 
@@ -131,7 +131,7 @@ namespace Mono.CSharp {
                        this.targs = targs;
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        Expression expr_resolved = expr.Resolve (ec,
                                ResolveFlags.VariableOrValue | ResolveFlags.Type |
@@ -218,7 +218,7 @@ namespace Mono.CSharp {
                        this.loc = l;
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        MemberList members = TypeManager.FindMembers (
                                ec.CurrentInitializerVariable.Type,

diff --git a/mcs/mcs/constant.cs b/mcs/mcs/constant.cs
index c59a1ff1544f70316f3a3f868bd27c9c11ef2e3d..d04de87e31af38af53a6d01e52394a1d94a33ec0 100644 (file)
--- a/mcs/mcs/constant.cs
+++ b/mcs/mcs/constant.cs
@@ -71,7 +71,7 @@ namespace Mono.CSharp {
                /// <summary>
                ///   Constants are always born in a fully resolved state
                /// </summary>
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }
@@ -1869,7 +1869,7 @@ namespace Mono.CSharp {
                        return GetSignatureForError ();
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }

diff --git a/mcs/mcs/convert.cs b/mcs/mcs/convert.cs
index a2fd752f26d8597247939c46f8c64701b1acca26..be0200a7124890e1d79f4d2248e0df8d70ed2690 100644 (file)
--- a/mcs/mcs/convert.cs
+++ b/mcs/mcs/convert.cs
@@ -1193,7 +1193,7 @@ namespace Mono.CSharp {
                                        return expr;
                                }
                        } else {
-                               expr = new UserCast (method, expr, loc).DoResolve (ec);
+                               expr = new UserCast (method, expr, loc).Resolve (ec);
 
                                if (return_convert && !TypeManager.IsEqual (expr.Type, target)) {
                                        if (look_for_explicit) {
@@ -1346,7 +1346,7 @@ namespace Mono.CSharp {
                                AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
                                Expression am = ame.Compatible (ec, target_type);
                                if (am != null)
-                                       return am.DoResolve (ec);
+                                       return am.Resolve (ec);
                        }
 
                        if (expr_type == InternalType.Arglist && target_type == TypeManager.arg_iterator_type)

diff --git a/mcs/mcs/delegate.cs b/mcs/mcs/delegate.cs
index 56a9066ffea6485270d3faf7697064fd65f67fd2..6956bb7afe32fad479bda36a3b0fbdc98731e0bc 100644 (file)
--- a/mcs/mcs/delegate.cs
+++ b/mcs/mcs/delegate.cs
@@ -519,7 +519,7 @@ namespace Mono.CSharp {
                        return e.CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        constructor_method = Delegate.GetConstructor (ec.Compiler, ec.CurrentType, type);
 
@@ -721,7 +721,7 @@ namespace Mono.CSharp {
                        this.loc  = loc; 
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (Arguments == null || Arguments.Count != 1) {
                                ec.Report.Error (149, loc, "Method name expected");
@@ -788,7 +788,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Invoke", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (InstanceExpr is EventExpr) {
                                ((EventExpr) InstanceExpr).Error_CannotAssign (ec);

diff --git a/mcs/mcs/dynamic.cs b/mcs/mcs/dynamic.cs
index e631f31db2c20f3e59efb442afe2dad550b44f6e..b9ea0f2f6b0d877fbaa8269c22d18d8e78560233 100644 (file)
--- a/mcs/mcs/dynamic.cs
+++ b/mcs/mcs/dynamic.cs
@@ -97,7 +97,7 @@ namespace Mono.CSharp
                        throw new NotImplementedException ();
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }
@@ -156,9 +156,9 @@ namespace Mono.CSharp
                        this.type = type;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
-                       expr = expr.DoResolve (ec);
+                       expr = expr.Resolve (ec);
                        eclass = ExprClass.Value;
                        return this;
                }
@@ -225,7 +225,7 @@ namespace Mono.CSharp
                                this.statement = statement;
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                Child = new IntConstant ((int) (flags | statement.flags), statement.loc);
 
@@ -291,7 +291,7 @@ namespace Mono.CSharp
                        return null;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index ce90b42138705b731c1ecfd689258df2ea77a78d..135deaaeaabbdedfbdd3187f06572689fbc90bd0 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -227,9 +227,9 @@ namespace Mono.CSharp {
                ///   to a valid type (this is the type of the
                ///   expression).
                /// </remarks>
-               public abstract Expression DoResolve (ResolveContext ec);
+               protected abstract Expression DoResolve (ResolveContext rc);
 
-               public virtual Expression DoResolveLValue (ResolveContext ec, Expression right_side)
+               public virtual Expression DoResolveLValue (ResolveContext rc, Expression right_side)
                {
                        return null;
                }
@@ -526,13 +526,7 @@ namespace Mono.CSharp {
                /// </summary>
                public Expression Resolve (ResolveContext ec)
                {
-                       Expression e = Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
-
-                       if (e != null && e.eclass == ExprClass.MethodGroup && RootContext.Version == LanguageVersion.ISO_1) {
-                               ((MethodGroupExpr) e).ReportUsageError (ec);
-                               return null;
-                       }
-                       return e;
+                       return Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup);
                }
 
                public Constant ResolveAsConstant (ResolveContext ec, MemberCore mc)
@@ -1385,7 +1379,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, ec.HasSet (ResolveContext.Options.CheckedScope) ? "ConvertChecked" : "Convert", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // This should never be invoked, we are born in fully
                        // initialized state.
@@ -1689,7 +1683,7 @@ namespace Mono.CSharp {
                {
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // This should never be invoked, we are born in fully
                        // initialized state.
@@ -1823,7 +1817,7 @@ namespace Mono.CSharp {
                        eclass = ExprClass.Value;
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // This should never be invoked, we are born in fully
                        // initialized state.
@@ -1856,7 +1850,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // This should never be invoked, we are born in fully
                        // initialized state.
@@ -1917,7 +1911,7 @@ namespace Mono.CSharp {
                        mode = m;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // This should never be invoked, we are born in fully
                        // initialized state.
@@ -2119,7 +2113,7 @@ namespace Mono.CSharp {
                        this.op = op;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // This should never be invoked, we are born in fully
                        // initialized state.
@@ -2242,7 +2236,7 @@ namespace Mono.CSharp {
                                return orig_expr.CreateExpressionTree (ec);
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                eclass = stm.eclass;
                                type = stm.Type;
@@ -2302,7 +2296,7 @@ namespace Mono.CSharp {
                        return orig_expr.CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        eclass = expr.eclass;
                        type = expr.Type;
@@ -2354,7 +2348,7 @@ namespace Mono.CSharp {
                        get { return expr; }
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        expr = expr.Resolve (ec);
                        if (expr != null) {
@@ -2558,7 +2552,7 @@ namespace Mono.CSharp {
                                (mc.LookupNamespaceOrType (Name, loc, /* ignore_cs0104 = */ true) != null);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return SimpleNameResolve (ec, null, false);
                }
@@ -2930,7 +2924,7 @@ namespace Mono.CSharp {
 
                                return (right_side != null)
                                        ? me.DoResolveLValue (ec, right_side)
-                                       : me.DoResolve (ec);
+                                       : me.Resolve (ec);
                        }
 
                        return e;
@@ -2985,7 +2979,7 @@ namespace Mono.CSharp {
                        return t;
                }
 
-               override public Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return ResolveAsTypeTerminal (ec, false);
                }
@@ -3741,10 +3735,10 @@ namespace Mono.CSharp {
                        return new TypeOfMethod (best_candidate, loc);
                }
                
-               override public Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (InstanceExpression != null) {
-                               InstanceExpression = InstanceExpression.DoResolve (ec);
+                               InstanceExpression = InstanceExpression.Resolve (ec);
                                if (InstanceExpression == null)
                                        return null;
                        }
@@ -4818,7 +4812,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        IConstant ic = TypeManager.GetConstant (constant);
                        if (ic.ResolveValue ()) {
@@ -4947,7 +4941,7 @@ namespace Mono.CSharp {
                        return new TypeOfField (GetConstructedFieldInfo (), loc);
                }
 
-               override public Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return DoResolve (ec, false, false);
                }
@@ -5560,7 +5554,7 @@ namespace Mono.CSharp {
                                return false;
                        }
 
-                       InstanceExpression = InstanceExpression.DoResolve (ec);
+                       InstanceExpression = InstanceExpression.Resolve (ec);
                        if (lvalue_instance && InstanceExpression != null)
                                InstanceExpression = InstanceExpression.ResolveLValue (ec, EmptyExpression.LValueMemberAccess);
 
@@ -5620,7 +5614,7 @@ namespace Mono.CSharp {
                        return t_name_len > 2 && t_name [t_name_len - 2] == '[';
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (resolved)
                                return this;
@@ -5637,7 +5631,7 @@ namespace Mono.CSharp {
                                        if (ex_method_lookup != null) {
                                                ex_method_lookup.ExtensionExpression = InstanceExpression;
                                                ex_method_lookup.SetTypeArguments (ec, targs);
-                                               return ex_method_lookup.DoResolve (ec);
+                                               return ex_method_lookup.Resolve (ec);
                                        }
                                }
 
@@ -5988,7 +5982,7 @@ namespace Mono.CSharp {
                                return false;
                        }
 
-                       InstanceExpression = InstanceExpression.DoResolve (ec);
+                       InstanceExpression = InstanceExpression.Resolve (ec);
                        if (InstanceExpression == null)
                                return false;
 
@@ -6034,7 +6028,7 @@ namespace Mono.CSharp {
                        return null;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        bool must_do_cs1540_check;
                        if (!(IsAccessorAccessible (ec.CurrentType, add_accessor, out must_do_cs1540_check) &&
@@ -6108,7 +6102,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (li != null)
                                return this;

diff --git a/mcs/mcs/eval.cs b/mcs/mcs/eval.cs
index a450d6b5186df1c7754add6b76748b531f4a7a5c..8414e61205762f65fadb3708f7a91ee966f62c5b 100644 (file)
--- a/mcs/mcs/eval.cs
+++ b/mcs/mcs/eval.cs
@@ -1148,7 +1148,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        CloneContext cc = new CloneContext ();
                        Expression clone = source.Clone (cc);

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 8326f217a1770f766957a867570428756d7c10e1..bbbed22a8f2968c2f613738cc7f5d481b753d64d 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -62,7 +62,7 @@ namespace Mono.CSharp {
                        // Nothing to clone
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        //
                        // We are born fully resolved
@@ -101,7 +101,7 @@ namespace Mono.CSharp {
                        loc = expr.Location;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return expr.Resolve (ec);
                }
@@ -430,7 +430,7 @@ namespace Mono.CSharp {
                        return expr;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (Oper == Operator.AddressOf) {
                                return ResolveAddressOf (ec);
@@ -861,7 +861,7 @@ namespace Mono.CSharp {
                        return DoResolve (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        expr = expr.Resolve (ec);
                        if (expr == null)
@@ -928,7 +928,7 @@ namespace Mono.CSharp {
                                throw new NotImplementedException ("ET");
                        }
 
-                       public override Expression DoResolve (ResolveContext rc)
+                       protected override Expression DoResolve (ResolveContext rc)
                        {
                                eclass = expr.eclass;
                                return this;
@@ -1005,7 +1005,7 @@ namespace Mono.CSharp {
                        return new SimpleAssign (this, this).CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        expr = expr.Resolve (ec);
                        
@@ -1204,7 +1204,7 @@ namespace Mono.CSharp {
                        }
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        probe_type_expr = ProbeType.ResolveAsTypeTerminal (ec, false);
                        if (probe_type_expr == null)
@@ -1310,7 +1310,7 @@ namespace Mono.CSharp {
                        return ReducedExpression.Create (new BoolConstant (result, loc), this);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (base.DoResolve (ec) == null)
                                return null;
@@ -1445,7 +1445,7 @@ namespace Mono.CSharp {
                                ig.Emit (OpCodes.Unbox_Any, type);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // Because expr is modified
                        if (eclass != ExprClass.Invalid)
@@ -1548,7 +1548,7 @@ namespace Mono.CSharp {
                        get { return target_type; }
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        expr = expr.Resolve (ec);
                        if (expr == null)
@@ -1607,7 +1607,7 @@ namespace Mono.CSharp {
                        this.arrayAccess = arrayAccess;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        expr = expr.Resolve (ec);
                        if (expr == null)
@@ -1643,7 +1643,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Constant", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        TypeExpr texpr = expr.ResolveAsTypeTerminal (ec, false);
                        if (texpr == null)
@@ -2612,7 +2612,7 @@ namespace Mono.CSharp {
                        return true;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (left == null)
                                return null;
@@ -3837,7 +3837,7 @@ namespace Mono.CSharp {
                        return CreateExpressionAddCall (ec, left, expr, pos);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }
@@ -3916,7 +3916,7 @@ namespace Mono.CSharp {
                        this.is_and = is_and;
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        MethodInfo method = (MethodInfo)mg;
                        type = TypeManager.TypeToCoreType (method.ReturnType);
@@ -3983,7 +3983,7 @@ namespace Mono.CSharp {
                        return null;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        eclass = ExprClass.Variable;
                        
@@ -4119,7 +4119,7 @@ namespace Mono.CSharp {
                        return base.CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // A boolean-expression is required to be of a type
                        // that can be implicitly converted to bool or of
@@ -4203,7 +4203,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Condition", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        expr = expr.Resolve (ec);
                        true_expr = true_expr.Resolve (ec);
@@ -4570,7 +4570,7 @@ namespace Mono.CSharp {
                        return this;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (resolved)
                                return this;
@@ -4820,7 +4820,7 @@ namespace Mono.CSharp {
                // the type as it is expected, but when we generate the code, we generate
                // the alternate kind of code.
                //
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (!DoResolveBase (ec))
                                return null;
@@ -4914,7 +4914,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Call", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        // Don't resolve already resolved expression
                        if (eclass != ExprClass.Invalid)
@@ -5407,7 +5407,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "New", args);
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        //
                        // The New DoResolve might be called twice when initializing field
@@ -6024,7 +6024,7 @@ namespace Mono.CSharp {
                        return true;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (type != null)
                                return this;
@@ -6488,7 +6488,7 @@ namespace Mono.CSharp {
                        }
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (type != null)
                                return this;
@@ -6576,7 +6576,7 @@ namespace Mono.CSharp {
                        this.type = type;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        eclass = ExprClass.Variable;
                        if (type == null)
@@ -6738,7 +6738,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Constant", args);
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        ResolveBase (ec);
                        return this;
@@ -6810,7 +6810,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        eclass = ExprClass.Variable;
                        type = TypeManager.runtime_argument_handle_type;
@@ -6871,7 +6871,7 @@ namespace Mono.CSharp {
                        return null;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        eclass = ExprClass.Variable;
                        type = InternalType.Arglist;
@@ -6925,7 +6925,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Constant", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;
@@ -7016,7 +7016,7 @@ namespace Mono.CSharp {
                        loc = l;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.type_type;
                        typearg = TypeManager.void_type;
@@ -7032,7 +7032,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (member is MethodInfo) {
                                type = TypeManager.methodinfo_type;
@@ -7107,7 +7107,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Constant", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        bool is_generic = TypeManager.IsGenericType (member.DeclaringType);
                        MethodInfo mi = is_generic ? TypeFromHandleGeneric : TypeFromHandle;
@@ -7162,7 +7162,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (TypeManager.fieldinfo_type == null)
                                TypeManager.fieldinfo_type = TypeManager.CoreLookupType (ec.Compiler, "System.Reflection", TypeName, Kind.Class, true);
@@ -7227,7 +7227,7 @@ namespace Mono.CSharp {
                        return null;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        TypeExpr texpr = QueriedType.ResolveAsTypeTerminal (ec, false);
                        if (texpr == null)
@@ -7317,7 +7317,7 @@ namespace Mono.CSharp {
                        return fne;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return ResolveAsTypeStep (ec, false);
                }
@@ -7458,7 +7458,7 @@ namespace Mono.CSharp {
                                                        ex_method_lookup.SetTypeArguments (ec, targs);
                                                }
 
-                                               return ex_method_lookup.DoResolve (ec);
+                                               return ex_method_lookup.Resolve (ec);
                                        }
                                }
 
@@ -7534,10 +7534,10 @@ namespace Mono.CSharp {
                        if (right_side != null)
                                return me.DoResolveLValue (ec, right_side);
                        else
-                               return me.DoResolve (ec);
+                               return me.Resolve (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return DoResolve (ec, null);
                }
@@ -7704,7 +7704,7 @@ namespace Mono.CSharp {
                                return Expr.CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        using (ec.With (ResolveContext.Options.AllCheckStateFlags, true))
                                Expr = Expr.Resolve (ec);
@@ -7773,7 +7773,7 @@ namespace Mono.CSharp {
                                return Expr.CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        using (ec.With (ResolveContext.Options.AllCheckStateFlags, false))
                                Expr = Expr.Resolve (ec);
@@ -7853,7 +7853,7 @@ namespace Mono.CSharp {
                        return new Indirection (p, loc).Resolve (ec);
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        Expr = Expr.Resolve (ec);
                        if (Expr == null)
@@ -7960,7 +7960,7 @@ namespace Mono.CSharp {
                        return DoResolve (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
 #if false
                        ExprClass eclass = ea.Expr.eclass;
@@ -8473,7 +8473,7 @@ namespace Mono.CSharp {
                        current_type = ec.CurrentType;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return ResolveAccessor (ec, null);
                }
@@ -8738,7 +8738,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        Expression c = CommonResolve (ec);
 
@@ -8927,7 +8927,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }
@@ -8975,7 +8975,7 @@ namespace Mono.CSharp {
                        // Do nothing
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.object_type;
                        return this;
@@ -9014,7 +9014,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Convert", args);
                }
                        
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        ObsoleteAttribute oa = AttributeTester.GetMethodObsoleteAttribute (method);
                        if (oa != null)
@@ -9151,7 +9151,7 @@ namespace Mono.CSharp {
                        array.Emit (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        //
                        // We are born fully resolved
@@ -9246,7 +9246,7 @@ namespace Mono.CSharp {
                        throw new NotSupportedException ("ET");
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        count = count.Resolve (ec);
                        if (count == null)
@@ -9340,7 +9340,7 @@ namespace Mono.CSharp {
                                args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (source == null)
                                return EmptyExpressionStatement.Instance;
@@ -9376,7 +9376,7 @@ namespace Mono.CSharp {
                        //
                        Constant c = source as Constant;
                        if (c != null && c.IsDefaultInitializer (type) && target.eclass == ExprClass.Variable)
-                               return EmptyExpressionStatement.Instance.DoResolve (ec);
+                               return EmptyExpressionStatement.Instance.Resolve (ec);
 
                        return expr;
                }
@@ -9469,7 +9469,7 @@ namespace Mono.CSharp {
                                target.arguments = arguments.Clone (clonectx);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;
@@ -9530,7 +9530,7 @@ namespace Mono.CSharp {
                        return new ImplicitlyTypedArrayCreation ("[]", expr_initializers, loc);
                }
                
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;
@@ -9641,7 +9641,7 @@ namespace Mono.CSharp {
                                throw new NotSupportedException ("ET");
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                return this;
                        }
@@ -9706,7 +9706,7 @@ namespace Mono.CSharp {
                                args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;
@@ -9839,7 +9839,7 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "New", args);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (ec.HasSet (ResolveContext.Options.ConstantScope)) {
                                ec.Report.Error (836, loc, "Anonymous types cannot be used in this expression");
@@ -9907,7 +9907,7 @@ namespace Mono.CSharp {
                        return Name.GetHashCode ();
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        Expression e = expr.Resolve (ec);
                        if (e == null)

diff --git a/mcs/mcs/iterators.cs b/mcs/mcs/iterators.cs
index 0b90679d02566db040fb90bc006692ec9ff8141a..7a139179413e0b2d0da146946c8378cfd24ed509 100644 (file)
--- a/mcs/mcs/iterators.cs
+++ b/mcs/mcs/iterators.cs
@@ -359,7 +359,7 @@ namespace Mono.CSharp {
                                this.method = method;
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                Methods = new MethodBase [] { method.MethodBuilder };
                                type = method.Parent.TypeBuilder;
@@ -378,7 +378,7 @@ namespace Mono.CSharp {
                                this.field = field;
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                FieldInfo = field.FieldBuilder;
                                type = TypeManager.TypeToCoreType (FieldInfo.FieldType);
@@ -827,7 +827,7 @@ namespace Mono.CSharp {
                        return OriginalMethod.GetSignatureForError ();
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        method = new AnonymousMethodMethod (Storey,
                                this, Storey, null, TypeManager.system_boolean_expr,

diff --git a/mcs/mcs/lambda.cs b/mcs/mcs/lambda.cs
index 64b48b1e5efca775248fb4e84419ad582e553b60..3f2cdcbe66f1c74364aff3c8042edb7e655d6178 100644 (file)
--- a/mcs/mcs/lambda.cs
+++ b/mcs/mcs/lambda.cs
@@ -101,7 +101,7 @@ namespace Mono.CSharp {
                        return Parameters;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        //
                        // Only explicit parameters can be resolved at this point

diff --git a/mcs/mcs/linq.cs b/mcs/mcs/linq.cs
index 4a0c86c7a7fcee4503409ddf7632acdf1b08111f..3af9e5ddc5a359626361d4bf14d9210b2056f1cc 100644 (file)
--- a/mcs/mcs/linq.cs
+++ b/mcs/mcs/linq.cs
@@ -33,7 +33,7 @@ namespace Mono.CSharp.Linq
                        return next.BuildQueryClause (ec, lSide);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        int counter = QueryBlock.TransparentParameter.Counter;
 
@@ -166,9 +166,9 @@ namespace Mono.CSharp.Linq
                                t.next = (AQueryClause) next.Clone (clonectx);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
-                       return expr.DoResolve (ec);
+                       return expr.Resolve (ec);
                }
 
                public virtual Expression BuildQueryClause (ResolveContext ec, Expression lSide)
@@ -283,7 +283,7 @@ namespace Mono.CSharp.Linq
                        return next.BuildQueryClause (ec, expr);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        Expression e = BuildQueryClause (ec, null);
                        return e.Resolve (ec);

diff --git a/mcs/mcs/literal.cs b/mcs/mcs/literal.cs
index aa30397723c2e407fe4f406649a191f519ed3f97..ac49c8e3d98f2cfa7a155333d23030d110827a26 100644 (file)
--- a/mcs/mcs/literal.cs
+++ b/mcs/mcs/literal.cs
@@ -116,7 +116,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.bool_type;
                        return this;
@@ -132,7 +132,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.char_type;
                        return this;
@@ -148,7 +148,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.int32_type;
                        return this;
@@ -179,7 +179,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.uint32_type;
                        return this;
@@ -195,7 +195,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.int64_type;
                        return this;
@@ -211,7 +211,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.uint64_type;
                        return this;
@@ -228,7 +228,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.float_type;
                        return this;
@@ -245,7 +245,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.double_type;
 
@@ -285,7 +285,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.decimal_type;
                        return this;
@@ -301,7 +301,7 @@ namespace Mono.CSharp {
                {
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        type = TypeManager.string_type;
 

diff --git a/mcs/mcs/namespace.cs b/mcs/mcs/namespace.cs
index 0b0df17dc9363d231a3cdcbe5fc9cb1fd166b467..f1e3cfd23bb5bb1244c852dfb80419693f5c94bb 100644 (file)
--- a/mcs/mcs/namespace.cs
+++ b/mcs/mcs/namespace.cs
@@ -404,7 +404,7 @@ namespace Mono.CSharp {
                        root.RegisterNamespace (this);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }

diff --git a/mcs/mcs/nullable.cs b/mcs/mcs/nullable.cs
index 307ebfb5d32515543b1ad707ecb54863d979d330..4e8883f0dd856c4d1814bc674984bf16dd37010a 100644 (file)
--- a/mcs/mcs/nullable.cs
+++ b/mcs/mcs/nullable.cs
@@ -137,7 +137,7 @@ namespace Mono.CSharp.Nullable
                        return expr.CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        return this;
                }
@@ -276,7 +276,7 @@ namespace Mono.CSharp.Nullable
                                throw new NotSupportedException ("ET");
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                return this;
                        }
@@ -404,7 +404,7 @@ namespace Mono.CSharp.Nullable
                        return expr.CreateExpressionTree (ec);
                }                       
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        //
                        // It's null when lifting non-nullable type
@@ -483,7 +483,7 @@ namespace Mono.CSharp.Nullable
                        return base.CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;
@@ -617,7 +617,7 @@ namespace Mono.CSharp.Nullable
                        return ReducedExpression.Create (c, this);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;
@@ -1053,7 +1053,7 @@ namespace Mono.CSharp.Nullable
                        return this;
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        if (eclass != ExprClass.Invalid)
                                return this;
@@ -1145,7 +1145,7 @@ namespace Mono.CSharp.Nullable
                        return new SimpleAssign (this, this).CreateExpressionTree (ec);
                }
 
-               public override Expression DoResolve (ResolveContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
                        expr = expr.Resolve (ec);
                        if (expr == null)

diff --git a/mcs/mcs/statement.cs b/mcs/mcs/statement.cs
index 06d4d1dcee281a129a5356c61ca158984057487a..79d32c1f4e679fb5e0d70a9f9ed7535d5bbb90b7 100644 (file)
--- a/mcs/mcs/statement.cs
+++ b/mcs/mcs/statement.cs
@@ -2545,7 +2545,7 @@ namespace Mono.CSharp {
                                throw new NotSupportedException ();
                        }
 
-                       public override Expression DoResolve (ResolveContext ec)
+                       protected override Expression DoResolve (ResolveContext ec)
                        {
                                if (child == null)
                                        return null;