C# Expression.DoResolveLValue方法代码示例

        public override Expression DoResolveLValue(ResolveContext rc, Expression right_side)
        {
            if (right_side == EmptyExpression.OutAccess.Instance) {
                right_side.DoResolveLValue (rc, this);
                return null;
            }

            if (DoResolveCore (rc)) {
                setter_args = new Arguments (Arguments.Count + 1);
                setter_args.AddRange (Arguments);
                setter_args.Add (new Argument (right_side));
                setter = CreateCallSiteBinder (rc, setter_args, true);
            }

            eclass = ExprClass.Variable;
            return this;
        }

		public override Expression DoResolveLValue (ResolveContext rc, Expression right_side)
		{
			if (right_side == EmptyExpression.OutAccess) {
				right_side.DoResolveLValue (rc, this);
				return null;
			}

			if (DoResolveCore (rc)) {
				setter_args = CreateSetterArguments (rc, right_side);
				setter = CreateCallSiteBinder (rc, setter_args, true);
			}

			eclass = ExprClass.Variable;
			return this;
		}

		public override Expression DoResolveLValue (ResolveContext rc, Expression right_side)
		{
			if (right_side == EmptyExpression.OutAccess) {
				right_side.DoResolveLValue (rc, this);
				return null;
			}

			var res_right_side = right_side.Resolve (rc);

			if (DoResolveCore (rc) && res_right_side != null) {
				setter_args = CreateSetterArguments (rc, res_right_side);

				// create setter callsite
				var dc = (binder as IDynamicCallSite);
				if (rc.Module.PredefinedTypes.IsPlayScriptAotMode && (dc != null) && dc.UseCallSite(rc, setter_args)) {
					this.useDelegateInvoke = false;
					setter_args.CreateDynamicBinderArguments(rc);
					setter = CreateCallSite(rc, setter_args, true);
				} else {
					this.useDelegateInvoke = true;
					setter = CreateCallSiteBinder (rc, setter_args, true);
				}
			}

			eclass = ExprClass.Variable;
			return this;
		}

        public override Expression DoResolveLValue(ResolveContext ec, Expression right_side)
        {
            eclass = ExprClass.PropertyAccess;

            if (right_side == EmptyExpression.OutAccess.Instance) {
                if (ec.CurrentBlock.Toplevel.GetParameterReference (spec.Name, loc) is MemberAccess) {
                    ec.Report.Error (1939, loc, "A range variable `{0}' may not be passes as `ref' or `out' parameter",
                        spec.Name);
                } else {
                    right_side.DoResolveLValue (ec, this);
                }
                return null;
            }

            if (right_side == EmptyExpression.LValueMemberAccess || right_side == EmptyExpression.LValueMemberOutAccess) {
                Error_CannotModifyIntermediateExpressionValue (ec);
            }

            if (spec.IsNotRealProperty) {
                Error_PropertyNotValid (ec);
                return null;
            }

            if (!spec.HasSet){
                if (ec.CurrentBlock.Toplevel.GetParameterReference (spec.Name, loc) is MemberAccess) {
                    ec.Report.Error (1947, loc, "A range variable `{0}' cannot be assigned to. Consider using `let' clause to store the value",
                        spec.Name);
                } else {
                    ec.Report.Error (200, loc, "Property or indexer `{0}' cannot be assigned to (it is read only)",
                        GetSignatureForError ());
                }
                return null;
            }

            if (targs != null) {
                base.SetTypeArguments (ec, targs);
                return null;
            }

            bool must_do_cs1540_check;
            if (!IsMemberAccessible (ec.CurrentType, spec.Set, out must_do_cs1540_check)) {
                if (spec.HasDifferentAccessibility) {
                    ec.Report.SymbolRelatedToPreviousError (spec.Set);
                    ec.Report.Error (272, loc, "The property or indexer `{0}' cannot be used in this context because the set accessor is inaccessible",
                        TypeManager.CSharpSignature (spec));
                } else {
                    ec.Report.SymbolRelatedToPreviousError (spec.Set);
                    ErrorIsInaccesible (loc, TypeManager.CSharpSignature (spec.Set), ec.Report);
                }
                return null;
            }

            if (!InstanceResolve (ec, TypeManager.IsStruct (spec.DeclaringType), must_do_cs1540_check))
                return null;

            //
            // Only base will allow this invocation to happen.
            //
            if (IsBase && spec.IsAbstract){
                Error_CannotCallAbstractBase (ec, TypeManager.GetFullNameSignature (spec));
            }

            if (spec.MemberType.IsPointer && !ec.IsUnsafe) {
                UnsafeError (ec, loc);
            }

            if (!ec.IsObsolete) {
                ObsoleteAttribute oa = spec.GetAttributeObsolete ();
                if (oa != null)
                    AttributeTester.Report_ObsoleteMessage (oa, GetSignatureForError (), loc, ec.Report);
            }

            return this;
        }

		public Expression DoResolve (EmitContext ec, Expression right_side, ResolveFlags flags)
		{
			if (type != null)
				throw new Exception ();
			//
			// Resolve the expression with flow analysis turned off, we'll do the definite
			// assignment checks later.  This is because we don't know yet what the expression
			// will resolve to - it may resolve to a FieldExpr and in this case we must do the
			// definite assignment check on the actual field and not on the whole struct.
			//

			Expression original = expr;
			expr = expr.Resolve (ec, flags | ResolveFlags.DisableFlowAnalysis);

			if (expr == null)
				return null;

			if (expr is SimpleName){
				SimpleName child_expr = (SimpleName) expr;
				
				Expression new_expr = new SimpleName (child_expr.Name, Identifier, loc);

				return new_expr.Resolve (ec, flags);
			}
					
			//
			// TODO: I mailed Ravi about this, and apparently we can get rid
			// of this and put it in the right place.
			// 
			// Handle enums here when they are in transit.
			// Note that we cannot afford to hit MemberLookup in this case because
			// it will fail to find any members at all
			//

			int errors = Report.Errors;
			
			Type expr_type = expr.Type;
			if ((expr is TypeExpr) &&
			    (expr_type == TypeManager.enum_type ||
			     expr_type.IsSubclassOf (TypeManager.enum_type))){
				
				Enum en = TypeManager.LookupEnum (expr_type);
				
				if (en != null) {
					object value = en.LookupEnumValue (ec, Identifier, loc);

					if (value != null){
						Constant c = Constantify (value, en.UnderlyingType);
						return new EnumConstant (c, expr_type);
					}
				}
			}

			if (expr_type.IsPointer){
				Error (23, "The `.' operator can not be applied to pointer operands (" +
				       TypeManager.CSharpName (expr_type) + ")");
				return null;
			}

			member_lookup = MemberLookupFinal (ec, expr_type, expr_type, Identifier, loc);
			if (member_lookup == null)
				return null;

			if (member_lookup is TypeExpr){
				member_lookup.Resolve (ec, ResolveFlags.Type);
				return member_lookup;
			} else if ((flags & ResolveFlags.MaskExprClass) == ResolveFlags.Type)
				return null;
			
			member_lookup = ResolveMemberAccess (ec, member_lookup, expr, loc, original);
			if (member_lookup == null)
				return null;

			// The following DoResolve/DoResolveLValue will do the definite assignment
			// check.

			if (right_side != null)
				member_lookup = member_lookup.DoResolveLValue (ec, right_side);
			else
				member_lookup = member_lookup.DoResolve (ec);

			return member_lookup;
		}