protected override Expression DoResolve (ResolveContext rc) { var sn = expr as SimpleName; const ResolveFlags flags = ResolveFlags.VariableOrValue | ResolveFlags.Type; if (sn != null) { expr = sn.LookupNameExpression (rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity); // // Resolve expression which does have type set as we need expression type // with disable flow analysis as we don't know whether left side expression // is used as variable or type // if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess) { expr = expr.Resolve (rc); } else if (expr is TypeParameterExpr) { expr.Error_UnexpectedKind (rc, flags, sn.Location); expr = null; } } else { expr = expr.Resolve (rc, flags); } if (expr == null) return null; TypeSpec expr_type = expr.Type; if (expr_type.IsPointer || expr_type.Kind == MemberKind.Void || expr_type == InternalType.NullLiteral || expr_type == InternalType.AnonymousMethod) { expr.Error_OperatorCannotBeApplied (rc, loc, ".", expr_type); return null; } if (targs != null) { if (!targs.Resolve (rc)) return null; } var results = new List<string> (); var nexpr = expr as NamespaceExpression; if (nexpr != null) { string namespaced_partial; if (partial_name == null) namespaced_partial = nexpr.Namespace.Name; else namespaced_partial = nexpr.Namespace.Name + "." + partial_name; rc.CurrentMemberDefinition.GetCompletionStartingWith (namespaced_partial, results); if (partial_name != null) results = results.Select (l => l.Substring (partial_name.Length)).ToList (); } else { var r = MemberCache.GetCompletitionMembers (rc, expr_type, partial_name).Select (l => l.Name); AppendResults (results, partial_name, r); } throw new CompletionResult (partial_name == null ? "" : partial_name, results.Distinct ().ToArray ()); }
protected override Expression DoResolve(ResolveContext ec) { if (Arguments == null || Arguments.Count != 1) { ec.Report.Error(149, loc, "Method name expected"); return(null); } Argument a = Arguments [0]; if (!a.ResolveMethodGroup(ec)) { return(null); } Expression e = a.Expr; AnonymousMethodExpression ame = e as AnonymousMethodExpression; if (ame != null && ec.Module.Compiler.Settings.Version != LanguageVersion.ISO_1) { e = ame.Compatible(ec, type); if (e == null) { return(null); } return(e.Resolve(ec)); } method_group = e as MethodGroupExpr; if (method_group == null) { if (e.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) { e = Convert.ImplicitConversionRequired(ec, e, type, loc); } else if (!e.Type.IsDelegate) { e.Error_UnexpectedKind(ec, ResolveFlags.MethodGroup | ResolveFlags.Type, loc); return(null); } // // An argument is not a method but another delegate // method_group = new MethodGroupExpr(Delegate.GetInvokeMethod(e.Type), e.Type, loc); method_group.InstanceExpression = e; } return(base.DoResolve(ec)); }
public override Expression DoResolve(ResolveContext ec) { if (Arguments == null || Arguments.Count != 1) { ec.Report.Error(149, loc, "Method name expected"); return(null); } Argument a = Arguments [0]; if (!a.ResolveMethodGroup(ec)) { return(null); } Expression e = a.Expr; AnonymousMethodExpression ame = e as AnonymousMethodExpression; if (ame != null && RootContext.Version != LanguageVersion.ISO_1) { e = ame.Compatible(ec, type); if (e == null) { return(null); } return(e.Resolve(ec)); } method_group = e as MethodGroupExpr; if (method_group == null) { if (!TypeManager.IsDelegateType(e.Type)) { e.Error_UnexpectedKind(ec, ResolveFlags.MethodGroup | ResolveFlags.Type, loc); return(null); } // // An argument is not a method but another delegate // delegate_instance_expression = e; method_group = new MethodGroupExpr(new MemberInfo [] { Delegate.GetInvokeMethod(ec.Compiler, ec.CurrentType, e.Type) }, e.Type, loc); } return(base.DoResolve(ec)); }
protected override Expression DoResolve(ResolveContext rc) { var sn = expr as SimpleName; const ResolveFlags flags = ResolveFlags.VariableOrValue | ResolveFlags.Type; // // 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. // using (rc.Set(ResolveContext.Options.OmitStructFlowAnalysis)) { if (sn != null) { expr = sn.LookupNameExpression(rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity); // // Resolve expression which does have type set as we need expression type // with disable flow analysis as we don't know whether left side expression // is used as variable or type // if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess) { using (rc.With(ResolveContext.Options.DoFlowAnalysis, false)) { expr = expr.Resolve(rc); } } else if (expr is TypeParameterExpr) { expr.Error_UnexpectedKind(rc, flags, sn.Location); expr = null; } } else { expr = expr.Resolve(rc, flags); } } if (expr == null) { return(null); } TypeSpec expr_type = expr.Type; if (expr_type.IsPointer || expr_type.Kind == MemberKind.Void || expr_type == InternalType.NullLiteral || expr_type == InternalType.AnonymousMethod) { expr.Error_OperatorCannotBeApplied(rc, loc, ".", expr_type); return(null); } if (targs != null) { if (!targs.Resolve(rc)) { return(null); } } var results = new List <string> (); if (expr is Namespace) { Namespace nexpr = expr as Namespace; string namespaced_partial; if (partial_name == null) { namespaced_partial = nexpr.Name; } else { namespaced_partial = nexpr.Name + "." + partial_name; } rc.CurrentMemberDefinition.GetCompletionStartingWith(namespaced_partial, results); if (partial_name != null) { results = results.Select(l => l.Substring(partial_name.Length)).ToList(); } } else { var r = MemberCache.GetCompletitionMembers(rc, expr_type, partial_name).Select(l => l.Name); AppendResults(results, partial_name, r); } throw new CompletionResult(partial_name == null ? "" : partial_name, results.Distinct().ToArray()); }