public bool ResolveCommon(ResolveContext rc)
{
ResolvedType = RequestedType.ResolveAsType(rc);
if (ResolvedType == null)
{
return(false);
}
eclass = ExprClass.Value;
//args
if (arguments != null)
{
arguments.Resolve(rc);
}
var tparam = ResolvedType as TypeParameterSpec;
if (tparam != null)
{
//
// Check whether the type of type parameter can be constructed. BaseType can be a struct for method overrides
// where type parameter constraint is inflated to struct
//
if (tparam.HasDefaultConstructorConstraint && !tparam.HasValueTypeConstraint)
{
rc.Report.Error(304, loc,
"Cannot create an instance of the variable type `{0}' because it does not have the new() constraint",
ResolvedType.ToString());
}
if ((arguments != null) && (arguments.Count != 0))
{
rc.Report.Error(417, loc,
"`{0}': cannot provide arguments when creating an instance of a variable type",
ResolvedType.ToString());
}
return(false);
}
if ((ResolvedType as ITypeDefinition).IsStatic)
{
rc.Report.Error(712, loc, "Cannot create an instance of the static class `{0}'", ResolvedType.ToString());
return(false);
}
if (ResolvedType.Kind == TypeKind.Interface || (ResolvedType as ITypeDefinition).IsAbstract)
{
rc.Report.Error(144, loc, "Cannot create an instance of the abstract class or interface `{0}'", ResolvedType.ToString());
return(false);
}
return(true);
}
public override Expression DoResolve(ResolveContext rc)
{
if (_resolved)
{
return(this);
}
count = count.DoResolve(rc);
if (count == null)
{
return(null);
}
if (!count.Type.IsKnownType(KnownTypeCode.UInt32))
{
count = new CastExpression(KnownTypeReference.UInt32.Resolve(rc), count).DoResolve(rc);
if (count == null)
{
return(null);
}
}
Constant c = count as Constant;
if (c != null && c.IsNegative)
{
rc.Report.Error(0, loc, "Cannot use a negative size with stackalloc");
}
if (rc.HasAny(ResolveContext.Options.CatchScope | ResolveContext.Options.FinallyScope))
{
rc.Report.Error(0, loc, "Cannot use stackalloc in finally or catch");
}
otype = texpr.ResolveAsType(rc);
if (otype == null)
{
return(null);
}
ResolvedType = new PointerTypeSpec(otype);
_resolved = true;
eclass = ExprClass.Value;
return(this);
}
public override Expression Constantify(ResolveContext resolver)
{
Expression rr;
if (expr is ITypeReference)
{
rr = new TypeExpression(expr.ResolveAsType(resolver), loc);
}
else if (expr is Constant)
{
rr = expr.DoResolve(resolver);
}
else
{
return(null);
}
IList <IType> typeArgs = typeArgumentsrefs.Resolve(resolver.CurrentTypeResolveContext);
return(ResolveMemberAccess(resolver, rr, name, typeArgs));
}
protected virtual void ResolveProbeType(ResolveContext rc)
{
probe_type_expr = ProbeType.ResolveAsType(rc);
}
public override Expression DoResolve(ResolveContext rc)
{
if (_resolved)
{
return(this);
}
expr = expr.DoResolve(rc);
if (expr == null)
{
return(null);
}
eclass = ExprClass.Value;
if (ResolvedType == null)
{
ResolvedType = target_type.ResolveAsType(rc);
if (ResolvedType == null)
{
return(null);
}
}
if (rc.IsStaticType(ResolvedType))
{
rc.Report.Error(246, loc, "Cannot convert to static type `{0}'", ResolvedType.ToString());
return(null);
}
// V# 4.0 spec: §7.7.6 Cast expressions
Conversion c = rc.conversions.ExplicitConversion(expr, ResolvedType);
if (!c.IsValid)
{
rc.Report.Error(196, Location, "Cannot convert source type `{0}' to target type `{1}'", expr.Type.ToString(), ResolvedType.ToString());
return(ErrorResult);
}
if (expr.IsCompileTimeConstant && !c.IsUserDefined)
{
TypeCode code = ReflectionHelper.GetTypeCode(ResolvedType);
if (code >= TypeCode.Boolean && code <= TypeCode.Decimal && expr.ConstantValue != null)
{
try
{
return(Constant.CreateConstantFromValue(rc, ResolvedType, rc.VSharpPrimitiveCast(code, expr.ConstantValue), loc));
}
catch (OverflowException)
{
return(new ErrorExpression(ResolvedType, loc));
}
catch (InvalidCastException)
{
return(new ErrorExpression(ResolvedType, loc));
}
}
else if (code == TypeCode.String)
{
if (expr.ConstantValue == null || expr.ConstantValue is string)
{
return(Constant.CreateConstantFromValue(rc, ResolvedType, expr.ConstantValue, loc));
}
else
{
return(new ErrorExpression(ResolvedType, loc));
}
}
else if (ResolvedType.Kind == TypeKind.Enum)
{
code = ReflectionHelper.GetTypeCode(ResolveContext.GetEnumUnderlyingType(ResolvedType));
if (code >= TypeCode.SByte && code <= TypeCode.UInt64 && expr.ConstantValue != null)
{
try
{
return(Constant.CreateConstantFromValue(rc, ResolvedType, rc.VSharpPrimitiveCast(code, expr.ConstantValue), loc));
}
catch (OverflowException)
{
return(new ErrorExpression(ResolvedType, loc));
}
catch (InvalidCastException)
{
return(new ErrorExpression(ResolvedType, loc));
}
}
}
}
return(new CastExpression(ResolvedType, expr, c, rc.checkForOverflow));
}
