public override Expression DoResolve(Runtime.ParseContext parseContext) { var typeExpression = _objectType = _objectType.ResolveAsTypeStep(parseContext, false); if (typeExpression == null) { return(base.DoResolve(parseContext)); } _arguments.Resolve(parseContext); Type = typeExpression.Type; var initializer = Initializer; if (initializer == null) { return(new NewExpression( _objectType, _arguments, Span).Resolve(parseContext)); } if (initializer is CollectionInitializerExpression) { var genericInterfaces = TypeManager.DropGenericTypeArguments(Type).GetInterfaces() .Where(o => o.IsGenericType) .Select(o => o.GetGenericTypeDefinition()); if (!genericInterfaces.Contains(TypeManager.CoreTypes.GenericEnumerableInterface)) { parseContext.ReportError( 1925, string.Format( "Cannot initialize object of type '{0}' with a collection initializer.", TypeManager.GetCSharpName(Type)), Span); } } return(new NewInitExpression( _objectType, _arguments, initializer, Span).Resolve(parseContext)); }
public override Expression DoResolve(ParseContext parseContext) { var targetResolved = Target.Resolve( parseContext, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup); if (targetResolved == null) { return(null); } Target = targetResolved; var arguments = Arguments; if (arguments != null) { _arguments.Resolve(parseContext); } _typeArguments.Resolve(parseContext); return(this); }
public override Expression DoResolve(ParseContext ec) { var typeExpression = _requestedType.ResolveAsTypeTerminal(ec, false); if (typeExpression == null) { return(null); } Type = _resolvedType = typeExpression.Type; if (Arguments == null) { var c = Constantify(_resolvedType); if (c != null) { return(ReducedExpression.Create(c, this)); } } if (TypeManager.IsGenericParameter(_resolvedType)) { var gc = TypeManager.GetTypeParameterConstraints(_resolvedType); if ((gc == null) || (!gc.HasConstructorConstraint && !gc.IsValueType)) { ec.ReportError( 304, string.Format( "Cannot create an instance of the variable type '{0}' because it doesn't have the new() constraint.", TypeManager.GetCSharpName(_resolvedType)), Span); return(null); } if ((_arguments != null) && (_arguments.Count != 0)) { ec.ReportError( 417, string.Format( "'{0}': cannot provide arguments when creating an instance of a variable type.", TypeManager.GetCSharpName(_resolvedType)), Span); return(null); } ExpressionClass = ExpressionClass.Value; return(this); } if (_resolvedType.IsAbstract && _resolvedType.IsSealed) { ec.ReportError( 712, string.Format( "Cannot create an instance of the static class '{0}'.", TypeManager.GetCSharpName(_resolvedType)), Span); return(null); } if (_resolvedType.IsInterface || _resolvedType.IsAbstract) { ec.ReportError( 144, string.Format( "Cannot create an instance of the abstract class or interface '{0}'.", TypeManager.GetCSharpName(_resolvedType)), Span); return(null); } var isStruct = TypeManager.IsStruct(_resolvedType); ExpressionClass = ExpressionClass.Value; // // SRE returns a match for .ctor () on structs (the object constructor), // so we have to manually ignore it. // if (isStruct && (_arguments != null) && !_arguments.Any()) { return(this); } // For member-lookup, treat 'new Foo (bar)' as call to 'foo.ctor (bar)', where 'foo' is of type 'Foo'. var memberLookup = MemberLookupFinal( ec, _resolvedType, _resolvedType, ConstructorInfo.ConstructorName, MemberTypes.Constructor, AllBindingFlags | BindingFlags.DeclaredOnly, Span); if (_arguments != null) { _arguments.Resolve(ec); } if (memberLookup == null) { return(null); } _constructor = memberLookup as MethodGroupExpression; if (_constructor == null) { memberLookup.OnErrorUnexpectedKind(ec, ResolveFlags.MethodGroup, Span); return(null); } _constructor = _constructor.OverloadResolve(ec, ref _arguments, false, Span); return((_constructor == null) ? null : this); }
public override Expression DoResolve(ParseContext ec) { // Don't resolve already resolved expression if (ExpressionClass != ExpressionClass.Invalid) { return(this); } var resolvedTarget = Target.Resolve(ec, ResolveFlags.VariableOrValue | ResolveFlags.MethodGroup); if (resolvedTarget == null) { return(null); } // Next, evaluate all the expressions in the argument list if (_arguments != null && !_argumentsResolved) { _arguments.Resolve(ec); _argumentsResolved = true; } var expressionType = resolvedTarget.Type; MethodGroup = resolvedTarget as MethodGroupExpression; if (MethodGroup == null) { if (expressionType != null && TypeManager.IsDelegateType(expressionType)) { MethodGroup = (resolvedTarget = new MemberAccessExpression { Left = resolvedTarget, Name = "Invoke", Span = Span }.Resolve(ec)) as MethodGroupExpression; } var memberExpression = resolvedTarget as MemberExpression; if (memberExpression == null) { resolvedTarget.OnErrorUnexpectedKind(ec, ResolveFlags.MethodGroup, Span); return(null); } if (MethodGroup == null) { MethodGroup = ec.LookupExtensionMethod( memberExpression.Type, memberExpression.Name, Span); if (MethodGroup != null) { ((ExtensionMethodGroupExpression)MethodGroup).ExtensionExpression = memberExpression.InstanceExpression; } } if (MethodGroup == null) { ec.ReportError( 1955, string.Format( "The member '{0}' cannot be used as method or delegate.", resolvedTarget.GetSignatureForError()), Span); return(null); } } MethodGroup = DoResolveOverload(ec); if (MethodGroup == null) { return(null); } var method = (MethodInfo)MethodGroup; if (method != null) { Type = method.ReturnType; // TODO: this is a copy of mg.ResolveMemberAccess method var instanceExpression = MethodGroup.InstanceExpression; if (method.IsStatic) { if (instanceExpression == null || instanceExpression is EmptyExpression || MethodGroup.IdenticalTypeName) { MethodGroup.InstanceExpression = null; } else { // TODO: MemberExpression.error176(ec, loc, mg.GetSignatureForError()); return(null); } } else { if (instanceExpression == null || instanceExpression == EmptyExpression.Null) { // TODO: SimpleName.Error_ObjectRefRequired(ec, loc, mg.GetSignatureForError()); } } } if (method == null) { return(null); } IsSpecialMethodInvocation(ec, method, Span); ExpressionClass = ExpressionClass.Value; return(this); }
public override Expression DoResolve(ParseContext parseContext) { _target = _target.Resolve(parseContext); _arguments.Resolve(parseContext); var typeExpression = _target as TypeExpression; if (typeExpression != null) { var indexers = typeExpression.Type .GetProperties(BindingFlags.Static | BindingFlags.Public) .Where(o => o.Name == "Item") .Select(o => o.GetGetMethod(false)) .Where(o => o.GetParameters().Length != 0) .ToArray(); if (indexers.Length == 0) { parseContext.ReportError( CompilerErrors.MissingIndexerValue, Span, typeExpression.GetSignatureForError()); return(null); // TODO } using (parseContext.Set(ParseContext.Options.InvokeSpecialName)) { return(new InvokeExpression( new MethodGroupExpression( indexers, typeExpression.Type, Span), _arguments).DoResolve(parseContext)); } } var propertyExpression = _target as PropertyExpression; if (propertyExpression != null) { var indexers = propertyExpression.Type .GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(o => o.Name == "Item") .Select(o => o.GetGetMethod(false)) .Where(o => o.GetParameters().Length != 0) .ToArray(); if (indexers.Length == 0) { parseContext.ReportError( CompilerErrors.MissingIndexerValue, Span, propertyExpression.Type.FullName); return(null); // TODO } using (parseContext.Set(ParseContext.Options.InvokeSpecialName)) { return(new InvokeExpression( new MethodGroupExpression( indexers, propertyExpression.Type, Span) { InstanceExpression = _target }, _arguments).DoResolve(parseContext)); } } _arguments.Resolve(parseContext); return(this); }