public void Resolve(VSC.TypeSystem.Resolver.ResolveContext rc)
{
// Verify that the argument is readable
if (ArgType != AType.Out)
{
Expr = Expr.DoResolve(rc);
}
// Verify that the argument is writeable
if (Expr != null && IsByRef)
{
Expr = Expr.DoResolveLeftValue(rc, EmptyExpression.OutAccess);
}
if (Expr == null)
{
Expr = Expression.ErrorResult;
}
}
public override VSC.AST.Expression DoResolve(VSC.TypeSystem.Resolver.ResolveContext rc)
{
if (_resolved)
{
return(this);
}
if (!ResolveCommon(rc))
{
return(null);
}
string[] argumentNames;
Expression[] rarguments = Arguments.GetArguments(out argumentNames);
initializers = (CollectionOrObjectInitializers)initializers.DoResolve(rc);
if (initializers == null)
{
return(null);
}
return(ResolveObjectCreation(rc, loc, ResolvedType, rarguments, argumentNames, false, initializers.Initializers));
}
public override VSC.AST.Expression DoResolve(VSC.TypeSystem.Resolver.ResolveContext rc)
{
if (ResolveCommon(rc) == null)
{
return(null);
}
ResolvedType = probe_type_expr;
eclass = ExprClass.Value;
IType etype = expr.Type;
if (ResolvedType.IsReferenceType.HasValue && !ResolvedType.IsReferenceType.Value && !NullableType.IsNullable(ResolvedType))
{
if (ResolvedType is TypeParameterSpec)
{
rc.Report.Error(413, loc,
"The `as' operator cannot be used with a non-reference type parameter `{0}'. Consider adding `class' or a reference type constraint",
probe_type_expr.ToString());
}
else
{
rc.Report.Error(77, loc,
"The `as' operator cannot be used with a non-nullable value type `{0}'",
ResolvedType.ToString());
}
return(null);
}
// If the compile-time type of E is dynamic, unlike the cast operator the as operator is not dynamically bound
if (etype.Kind == TypeKind.Dynamic)
{
return(this);
}
return(new CastExpression(probe_type_expr, expr, Conversion.TryCast, rc.checkForOverflow, loc));
}
public override VSC.AST.Expression DoResolve(VSC.TypeSystem.Resolver.ResolveContext rc)
{
List <string> element_names = null;
for (int i = 0; i < initializers.Count; ++i)
{
Expression initializer = initializers[i];
ElementInitializer element_initializer = initializer as ElementInitializer;
if (i == 0)
{
if (element_initializer != null)
{
element_names = new List <string>(initializers.Count);
element_names.Add(element_initializer.Name);
}
//else if (initializer is CompletingExpression)//TODO:Add complete
//{
// initializer.Resolve(ec);
// throw new InternalErrorException("This line should never be reached");
//}
else
{
var t = rc.CurrentObjectInitializerType;
// LAMESPEC: The collection must implement IEnumerable only, no dynamic support
if (!t.Implements(KnownTypeReference.IEnumerable.Resolve(rc)))
{
rc.Report.Error(0, loc, "A field or property `{0}' cannot be initialized with a collection " +
"object initializer because type `{1}' does not implement `{2}' interface",
rc.CurrentObjectInitializer.GetSignatureForError(),
rc.CurrentObjectInitializerType.ToString(),
KnownTypeReference.IEnumerable.ToString());
return(null);
}
is_collection_initialization = true;
}
}
else
{
if (is_collection_initialization != (element_initializer == null))
{
rc.Report.Error(0, initializer.Location, "Inconsistent `{0}' member declaration",
is_collection_initialization ? "collection initializer" : "object initializer");
continue;
}
if (!is_collection_initialization)
{
if (element_names.Contains(element_initializer.Name))
{
rc.Report.Error(0, element_initializer.Location,
"An object initializer includes more than one member `{0}' initialization",
element_initializer.Name);
}
else
{
element_names.Add(element_initializer.Name);
}
}
}
Expression e = initializer.DoResolve(rc);
if (e == EmptyExpressionStatement.Instance)
{
initializers.RemoveAt(i--);
}
else
{
initializers[i] = e;
}
}
ResolvedType = rc.CurrentObjectInitializerType;
if (is_collection_initialization)
{
if (ResolvedType is ElementTypeSpec)
{
rc.Report.Error(0, loc, "Cannot initialize object of type `{0}' with a collection initializer",
ResolvedType.ToString());
}
}
eclass = ExprClass.Variable;
return(this);
}
