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