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);
}
