protected override Expression DoResolve (ResolveContext ec)
{
var results = new List<string> ();
ec.CurrentMemberDefinition.GetCompletionStartingWith (Prefix, results);
throw new CompletionResult (Prefix, results.Distinct ().Select (l => l.Substring (Prefix.Length)).ToArray ());
}
public Constant ImplicitConversionRequired (ResolveContext ec, TypeSpec type)
{
Constant c = ConvertImplicitly (type);
if (c == null)
Error_ValueCannotBeConverted (ec, type, false);
return c;
}
public override void Error_ValueCannotBeConverted (ResolveContext ec, TypeSpec target, bool expl)
{
if (!expl && IsLiteral && type.BuiltinType != BuiltinTypeSpec.Type.Double &&
BuiltinTypeSpec.IsPrimitiveTypeOrDecimal (target) &&
BuiltinTypeSpec.IsPrimitiveTypeOrDecimal (type)) {
ec.Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'",
GetValueAsLiteral (), target.GetSignatureForError ());
} else {
base.Error_ValueCannotBeConverted (ec, target, expl);
}
}
public override void Error_ValueCannotBeConverted (ResolveContext ec, TypeSpec t, bool expl)
{
if (t.IsGenericParameter) {
ec.Report.Error(403, loc,
"Cannot convert null to the type parameter `{0}' because it could be a value " +
"type. Consider using `default ({0})' instead", t.Name);
return;
}
if (TypeSpec.IsValueType (t)) {
ec.Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type",
t.GetSignatureForError ());
return;
}
base.Error_ValueCannotBeConverted (ec, t, expl);
}
static bool ConvertPromotion (ResolveContext rc, ref Constant prim, ref Constant second, TypeSpec type)
{
Constant c = prim.ConvertImplicitly (type);
if (c != null) {
prim = c;
return true;
}
if (type.BuiltinType == BuiltinTypeSpec.Type.UInt) {
type = rc.BuiltinTypes.Long;
prim = prim.ConvertImplicitly (type);
second = second.ConvertImplicitly (type);
return prim != null && second != null;
}
return false;
}
//
// Performs the numeric promotions on the left and right expresions
// and deposits the results on `lc' and `rc'.
//
// On success, the types of `lc' and `rc' on output will always match,
// and the pair will be one of:
//
// TODO: BinaryFold should be called as an optimization step only,
// error checking here is weak
//
static bool DoBinaryNumericPromotions (ResolveContext rc, ref Constant left, ref Constant right)
{
TypeSpec ltype = left.Type;
TypeSpec rtype = right.Type;
foreach (TypeSpec t in rc.BuiltinTypes.BinaryPromotionsTypes) {
if (t == ltype)
return t == rtype || ConvertPromotion (rc, ref right, ref left, t);
if (t == rtype)
return t == ltype || ConvertPromotion (rc, ref left, ref right, t);
}
left = left.ConvertImplicitly (rc.BuiltinTypes.Int);
right = right.ConvertImplicitly (rc.BuiltinTypes.Int);
return left != null && right != null;
}
protected override ParametersCompiled ResolveParameters (ResolveContext ec, TypeInferenceContext tic, TypeSpec delegateType)
{
if (!delegateType.IsDelegate)
return null;
AParametersCollection d_params = Delegate.GetParameters (delegateType);
if (HasExplicitParameters) {
if (!VerifyExplicitParameters (ec, tic, delegateType, d_params))
return null;
return Parameters;
}
//
// If L has an implicitly typed parameter list we make implicit parameters explicit
// Set each parameter of L is given the type of the corresponding parameter in D
//
if (!VerifyParameterCompatibility (ec, tic, delegateType, d_params, ec.IsInProbingMode))
return null;
TypeSpec [] ptypes = new TypeSpec [Parameters.Count];
for (int i = 0; i < d_params.Count; i++) {
// D has no ref or out parameters
if ((d_params.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) != 0)
return null;
TypeSpec d_param = d_params.Types [i];
//
// When type inference context exists try to apply inferred type arguments
//
if (tic != null) {
d_param = tic.InflateGenericArgument (ec, d_param);
}
ptypes [i] = d_param;
ImplicitLambdaParameter ilp = (ImplicitLambdaParameter) Parameters.FixedParameters [i];
ilp.SetParameterType (d_param);
ilp.Resolve (null, i);
}
Parameters.Types = ptypes;
return Parameters;
}
public override Constant ConvertInitializer (ResolveContext rc, Constant expr)
{
if (expr is EnumConstant)
expr = ((EnumConstant) expr).Child;
var en = (Enum)Parent;
var underlying = en.UnderlyingType;
if (expr != null) {
expr = expr.ImplicitConversionRequired (rc, underlying);
if (expr != null && !IsValidEnumType (expr.Type)) {
en.Error_UnderlyingType (Location);
expr = null;
}
}
if (expr == null)
expr = New.Constantify (underlying, Location);
return new EnumConstant (expr, MemberType);
}
protected override Expression CreateExpressionTree (ResolveContext ec, TypeSpec delegate_type)
{
if (ec.IsInProbingMode)
return this;
BlockContext bc = new BlockContext (ec.MemberContext, ec.ConstructorBlock, ec.BuiltinTypes.Void) {
CurrentAnonymousMethod = ec.CurrentAnonymousMethod
};
Expression args = Parameters.CreateExpressionTree (bc, loc);
Expression expr = Block.CreateExpressionTree (ec);
if (expr == null)
return null;
Arguments arguments = new Arguments (2);
arguments.Add (new Argument (expr));
arguments.Add (new Argument (args));
return CreateExpressionFactoryCall (ec, "Lambda",
new TypeArguments (new TypeExpression (delegate_type, loc)),
arguments);
}
public override Expression DoResolveLValue(ResolveContext ec, Expression right_side)
{
return(this);
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (4);
MemberAccess sle = new MemberAccess (new MemberAccess (
new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Linq", loc), "Expressions", loc);
var flags = ec.HasSet (ResolveContext.Options.CheckedScope) ? CSharpBinderFlags.CheckedContext : 0;
binder_args.Add (new Argument (new BinderFlags (flags, this)));
binder_args.Add (new Argument (new MemberAccess (new MemberAccess (sle, "ExpressionType", loc), name, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
return new Invocation (GetBinder ("UnaryOperation", loc), binder_args);
}
public override Expression DoResolveLValue (ResolveContext rc, Expression right_side)
{
if (right_side == EmptyExpression.OutAccess) {
right_side.DoResolveLValue (rc, this);
return null;
}
if (DoResolveCore (rc)) {
setter_args = CreateSetterArguments (rc, right_side);
setter = CreateCallSiteBinder (rc, setter_args, true);
}
eclass = ExprClass.Variable;
return this;
}
public override Expression CreateExpressionTree(ResolveContext ec)
{
return(condition.CreateExpressionTree(ec));
}
protected override Arguments CreateSetterArguments (ResolveContext rc, Expression rhs)
{
//
// Indexer has arguments which complicates things as the setter and getter
// are called in two steps when unary mutator is used. We have to make a
// copy of all variable arguments to not duplicate any side effect.
//
// ++d[++arg, Foo ()]
//
if (!can_be_mutator)
return base.CreateSetterArguments (rc, rhs);
var setter_args = new Arguments (Arguments.Count + 1);
for (int i = 0; i < Arguments.Count; ++i) {
var expr = Arguments[i].Expr;
if (expr is Constant || expr is VariableReference || expr is This) {
setter_args.Add (Arguments [i]);
continue;
}
LocalVariable temp = LocalVariable.CreateCompilerGenerated (expr.Type, rc.CurrentBlock, loc);
expr = new SimpleAssign (temp.CreateReferenceExpression (rc, expr.Location), expr).Resolve (rc);
Arguments[i].Expr = temp.CreateReferenceExpression (rc, expr.Location).Resolve (rc);
setter_args.Add (Arguments [i].Clone (expr));
}
setter_args.Add (new Argument (rhs));
return setter_args;
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (3);
binder_args.Add (new Argument (new BinderFlags (0, this)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
return new Invocation (GetBinder ("InvokeConstructor", loc), binder_args);
}
public override void Emit (EmitContext ec)
{
var rc = new ResolveContext (ec.MemberContext);
var expr = new Conditional (new BooleanExpression (condition), invoke, assign, loc).Resolve (rc);
expr.Emit (ec);
}
public override Expression CreateExpressionTree(ResolveContext ec)
{
return(null);
}
protected override Expression DoResolve(ResolveContext ec)
{
constructor_method = Delegate.GetConstructor(type);
var invoke_method = Delegate.GetInvokeMethod(type);
if (!ec.HasSet(ResolveContext.Options.ConditionalAccessReceiver))
{
if (method_group.HasConditionalAccess())
{
conditional_access_receiver = true;
ec.Set(ResolveContext.Options.ConditionalAccessReceiver);
}
}
Arguments arguments = CreateDelegateMethodArguments(ec, invoke_method.Parameters, invoke_method.Parameters.Types, loc);
method_group = method_group.OverloadResolve(ec, ref arguments, this, OverloadResolver.Restrictions.CovariantDelegate);
if (conditional_access_receiver)
{
ec.With(ResolveContext.Options.ConditionalAccessReceiver, false);
}
if (method_group == null)
{
return(null);
}
var delegate_method = method_group.BestCandidate;
if (delegate_method.DeclaringType.IsNullableType)
{
ec.Report.Error(1728, loc, "Cannot create delegate from method `{0}' because it is a member of System.Nullable<T> type",
delegate_method.GetSignatureForError());
return(null);
}
if (!AllowSpecialMethodsInvocation)
{
Invocation.IsSpecialMethodInvocation(ec, delegate_method, loc);
}
if (method_group is ExtensionMethodGroupExpr emg)
{
method_group.InstanceExpression = emg.ExtensionExpression;
TypeSpec e_type = emg.ExtensionExpression.Type;
if (TypeSpec.IsValueType(e_type))
{
ec.Report.Error(1113, loc, "Extension method `{0}' of value type `{1}' cannot be used to create delegates",
delegate_method.GetSignatureForError(), e_type.GetSignatureForError());
}
}
TypeSpec rt = method_group.BestCandidateReturnType;
if (rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
{
rt = ec.BuiltinTypes.Object;
}
if (!Delegate.IsTypeCovariant(ec, rt, invoke_method.ReturnType))
{
Expression ret_expr = new TypeExpression(delegate_method.ReturnType, loc);
Error_ConversionFailed(ec, delegate_method, ret_expr);
}
if (method_group.IsConditionallyExcluded)
{
ec.Report.SymbolRelatedToPreviousError(delegate_method);
if (delegate_method.MemberDefinition is MethodOrOperator m && m.IsPartialDefinition)
{
ec.Report.Error(762, loc, "Cannot create delegate from partial method declaration `{0}'",
delegate_method.GetSignatureForError());
}
else
{
ec.Report.Error(1618, loc, "Cannot create delegate with `{0}' because it has a Conditional attribute",
TypeManager.CSharpSignature(delegate_method));
}
}
public override Expression CreateExpressionTree(ResolveContext ec)
{
throw new NotSupportedException();
}
protected abstract Expression CreateCallSiteBinder(ResolveContext ec, Arguments args, bool isSet);
public Expression CreateCallSiteBinder(ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments(member != null ? 5 : 3);
bool is_member_access = member is MemberAccess;
CSharpBinderFlags call_flags;
if (!is_member_access && member is SimpleName)
{
call_flags = CSharpBinderFlags.InvokeSimpleName;
is_member_access = true;
}
else
{
call_flags = 0;
}
binder_args.Add(new Argument(new BinderFlags(call_flags, this)));
if (is_member_access)
{
binder_args.Add(new Argument(new StringLiteral(ec.BuiltinTypes, member.Name, member.Location)));
}
if (member != null && member.HasTypeArguments)
{
TypeArguments ta = member.TypeArguments;
if (ta.Resolve(ec, false))
{
var targs = new ArrayInitializer(ta.Count, loc);
foreach (TypeSpec t in ta.Arguments)
{
targs.Add(new TypeOf(t, loc));
}
binder_args.Add(new Argument(new ImplicitlyTypedArrayCreation(targs, loc)));
}
}
else if (is_member_access)
{
binder_args.Add(new Argument(new NullLiteral(loc)));
}
binder_args.Add(new Argument(new TypeOf(ec.CurrentType, loc)));
Expression real_args;
if (args == null)
{
// Cannot be null because .NET trips over
real_args = new ArrayCreation(
new MemberAccess(GetBinderNamespace(loc), "CSharpArgumentInfo", loc),
new ArrayInitializer(0, loc), loc);
}
else
{
real_args = new ImplicitlyTypedArrayCreation(args.CreateDynamicBinderArguments(ec), loc);
}
binder_args.Add(new Argument(real_args));
return(new Invocation(GetBinder(is_member_access ? "InvokeMember" : "Invoke", loc), binder_args));
}
protected override Expression DoResolve(ResolveContext ec)
{
can_be_mutator = true;
return(base.DoResolve(ec));
}
public override Expression CreateExpressionTree (ResolveContext ec)
{
return condition.CreateExpressionTree (ec);
}
protected override Expression DoResolve (ResolveContext rc)
{
type = rc.BuiltinTypes.Dynamic;
eclass = ExprClass.Value;
condition = condition.Resolve (rc);
return this;
}
protected override Expression DoResolve(ResolveContext ec)
{
expr = expr.Resolve(ec);
eclass = ExprClass.Value;
return(this);
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (3);
flags |= ec.HasSet (ResolveContext.Options.CheckedScope) ? CSharpBinderFlags.CheckedContext : 0;
binder_args.Add (new Argument (new BinderFlags (flags, this)));
binder_args.Add (new Argument (new TypeOf (type, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
return new Invocation (GetBinder ("Convert", loc), binder_args);
}
protected override Expression CreateCallSiteBinder (ResolveContext ec, Arguments args, bool isSet)
{
Arguments binder_args = new Arguments (4);
binder_args.Add (new Argument (new BinderFlags (flags, this)));
binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, name, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
isSet |= (flags & CSharpBinderFlags.ValueFromCompoundAssignment) != 0;
return new Invocation (GetBinder (isSet ? "SetMember" : "GetMember", loc), binder_args);
}
protected override Expression DoResolve (ResolveContext ec)
{
can_be_mutator = true;
return base.DoResolve (ec);
}
protected abstract Expression CreateCallSiteBinder (ResolveContext ec, Arguments args, bool isSet);
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
Arguments binder_args = new Arguments (member != null ? 5 : 3);
bool is_member_access = member is MemberAccess;
CSharpBinderFlags call_flags;
if (!is_member_access && member is SimpleName) {
call_flags = CSharpBinderFlags.InvokeSimpleName;
is_member_access = true;
} else {
call_flags = 0;
}
binder_args.Add (new Argument (new BinderFlags (call_flags, this)));
if (is_member_access)
binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, member.Name, member.Location)));
if (member != null && member.HasTypeArguments) {
TypeArguments ta = member.TypeArguments;
if (ta.Resolve (ec, false)) {
var targs = new ArrayInitializer (ta.Count, loc);
foreach (TypeSpec t in ta.Arguments)
targs.Add (new TypeOf (t, loc));
binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (targs, loc)));
}
} else if (is_member_access) {
binder_args.Add (new Argument (new NullLiteral (loc)));
}
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
Expression real_args;
if (args == null) {
// Cannot be null because .NET trips over
real_args = new ArrayCreation (
new MemberAccess (GetBinderNamespace (loc), "CSharpArgumentInfo", loc),
new ArrayInitializer (0, loc), loc);
} else {
real_args = new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc);
}
binder_args.Add (new Argument (real_args));
return new Invocation (GetBinder (is_member_access ? "InvokeMember" : "Invoke", loc), binder_args);
}
public override Expression CreateExpressionTree(ResolveContext ec)
{
ec.Report.Error(1963, loc, "An expression tree cannot contain a dynamic operation");
return(null);
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
//
// DoResolve always uses getter
//
return CreateCallSiteBinder (ec, args, false);
}
internal static void Error_CompileTimeOverflow (ResolveContext rc, Location loc)
{
rc.Report.Error (220, loc, "The operation overflows at compile time in checked mode");
}
protected virtual Arguments CreateSetterArguments (ResolveContext rc, Expression rhs)
{
var setter_args = new Arguments (Arguments.Count + 1);
setter_args.AddRange (Arguments);
setter_args.Add (new Argument (rhs));
return setter_args;
}
protected override Expression DoResolve(ResolveContext rc)
{
throw new CompletionResult("", new string [0]);
}
public static DynamicUnaryConversion CreateIsFalse (ResolveContext rc, Arguments args, Location loc)
{
return new DynamicUnaryConversion ("IsFalse", args, loc) { type = rc.BuiltinTypes.Bool };
}
public Expression CreateCallSiteBinder (ResolveContext ec, Arguments args)
{
type = ec.BuiltinTypes.Bool;
Arguments binder_args = new Arguments (3);
binder_args.Add (new Argument (new BinderFlags (0, this)));
binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, name, loc)));
binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
return new Invocation (GetBinder ("IsEvent", loc), binder_args);
}
//
// Creates a proxy base method call inside this container for hoisted base member calls
//
public MethodSpec CreateHoistedBaseCallProxy (ResolveContext rc, MethodSpec method)
{
Method proxy_method;
//
// One proxy per base method is enough
//
if (hoisted_base_call_proxies == null) {
hoisted_base_call_proxies = new Dictionary<MethodSpec, Method> ();
proxy_method = null;
} else {
hoisted_base_call_proxies.TryGetValue (method, out proxy_method);
}
if (proxy_method == null) {
string name = CompilerGeneratedContainer.MakeName (method.Name, null, "BaseCallProxy", hoisted_base_call_proxies.Count);
MemberName member_name;
TypeArguments targs = null;
TypeSpec return_type = method.ReturnType;
var local_param_types = method.Parameters.Types;
if (method.IsGeneric) {
//
// Copy all base generic method type parameters info
//
var hoisted_tparams = method.GenericDefinition.TypeParameters;
var tparams = new TypeParameters ();
targs = new TypeArguments ();
targs.Arguments = new TypeSpec[hoisted_tparams.Length];
for (int i = 0; i < hoisted_tparams.Length; ++i) {
var tp = hoisted_tparams[i];
var local_tp = new TypeParameter (tp, null, new MemberName (tp.Name, Location), null);
tparams.Add (local_tp);
targs.Add (new SimpleName (tp.Name, Location));
targs.Arguments[i] = local_tp.Type;
}
member_name = new MemberName (name, tparams, Location);
//
// Mutate any method type parameters from original
// to newly created hoisted version
//
var mutator = new TypeParameterMutator (hoisted_tparams, tparams);
return_type = mutator.Mutate (return_type);
local_param_types = mutator.Mutate (local_param_types);
} else {
member_name = new MemberName (name);
}
var base_parameters = new Parameter[method.Parameters.Count];
for (int i = 0; i < base_parameters.Length; ++i) {
var base_param = method.Parameters.FixedParameters[i];
base_parameters[i] = new Parameter (new TypeExpression (local_param_types [i], Location),
base_param.Name, base_param.ModFlags, null, Location);
base_parameters[i].Resolve (this, i);
}
var cloned_params = ParametersCompiled.CreateFullyResolved (base_parameters, method.Parameters.Types);
if (method.Parameters.HasArglist) {
cloned_params.FixedParameters[0] = new Parameter (null, "__arglist", Parameter.Modifier.NONE, null, Location);
cloned_params.Types[0] = Module.PredefinedTypes.RuntimeArgumentHandle.Resolve ();
}
// Compiler generated proxy
proxy_method = new Method (this, new TypeExpression (return_type, Location),
Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN,
member_name, cloned_params, null);
var block = new ToplevelBlock (Compiler, proxy_method.ParameterInfo, Location) {
IsCompilerGenerated = true
};
var mg = MethodGroupExpr.CreatePredefined (method, method.DeclaringType, Location);
mg.InstanceExpression = new BaseThis (method.DeclaringType, Location);
if (targs != null)
mg.SetTypeArguments (rc, targs);
// Get all the method parameters and pass them as arguments
var real_base_call = new Invocation (mg, block.GetAllParametersArguments ());
Statement statement;
if (method.ReturnType.Kind == MemberKind.Void)
statement = new StatementExpression (real_base_call);
else
statement = new Return (real_base_call, Location);
block.AddStatement (statement);
proxy_method.Block = block;
members.Add (proxy_method);
proxy_method.Define ();
proxy_method.PrepareEmit ();
hoisted_base_call_proxies.Add (method, proxy_method);
}
return proxy_method.Spec;
}
protected override Expression DoResolve(ResolveContext ec)
{
return(this);
}
protected override Expression DoResolve (ResolveContext rc)
{
if (DoResolveCore (rc))
binder_expr = binder.CreateCallSiteBinder (rc, arguments);
return this;
}
protected bool DoResolveCore (ResolveContext rc)
{
foreach (var arg in arguments) {
if (arg.Type == InternalType.VarOutType) {
// Should be special error message about dynamic dispatch
rc.Report.Error (8047, arg.Expr.Location, "Declaration expression cannot be used in this context");
}
}
if (rc.CurrentTypeParameters != null && rc.CurrentTypeParameters[0].IsMethodTypeParameter)
context_mvars = rc.CurrentTypeParameters;
int errors = rc.Report.Errors;
var pt = rc.Module.PredefinedTypes;
binder_type = pt.Binder.Resolve ();
pt.CallSite.Resolve ();
pt.CallSiteGeneric.Resolve ();
eclass = ExprClass.Value;
if (type == null)
type = rc.BuiltinTypes.Dynamic;
if (rc.Report.Errors == errors)
return true;
rc.Report.Error (1969, loc,
"Dynamic operation cannot be compiled without `Microsoft.CSharp.dll' assembly reference");
return false;
}
/// <summary>
/// Constant expression folder for binary operations.
///
/// Returns null if the expression can not be folded.
/// </summary>
static public Constant BinaryFold (ResolveContext ec, Binary.Operator oper,
Constant left, Constant right, Location loc)
{
Constant result = null;
if (left is EmptyConstantCast)
return BinaryFold (ec, oper, ((EmptyConstantCast)left).child, right, loc);
if (left is SideEffectConstant) {
result = BinaryFold (ec, oper, ((SideEffectConstant) left).value, right, loc);
if (result == null)
return null;
return new SideEffectConstant (result, left, loc);
}
if (right is EmptyConstantCast)
return BinaryFold (ec, oper, left, ((EmptyConstantCast)right).child, loc);
if (right is SideEffectConstant) {
result = BinaryFold (ec, oper, left, ((SideEffectConstant) right).value, loc);
if (result == null)
return null;
return new SideEffectConstant (result, right, loc);
}
TypeSpec lt = left.Type;
TypeSpec rt = right.Type;
bool bool_res;
if (lt.BuiltinType == BuiltinTypeSpec.Type.Bool && lt == rt) {
bool lv = (bool) left.GetValue ();
bool rv = (bool) right.GetValue ();
switch (oper) {
case Binary.Operator.BitwiseAnd:
case Binary.Operator.LogicalAnd:
return new BoolConstant (ec.BuiltinTypes, lv && rv, left.Location);
case Binary.Operator.BitwiseOr:
case Binary.Operator.LogicalOr:
return new BoolConstant (ec.BuiltinTypes, lv || rv, left.Location);
case Binary.Operator.ExclusiveOr:
return new BoolConstant (ec.BuiltinTypes, lv ^ rv, left.Location);
case Binary.Operator.Equality:
return new BoolConstant (ec.BuiltinTypes, lv == rv, left.Location);
case Binary.Operator.Inequality:
return new BoolConstant (ec.BuiltinTypes, lv != rv, left.Location);
}
return null;
}
//
// During an enum evaluation, none of the rules are valid
// Not sure whether it is bug in csc or in documentation
//
if (ec.HasSet (ResolveContext.Options.EnumScope)){
if (left is EnumConstant)
left = ((EnumConstant) left).Child;
if (right is EnumConstant)
right = ((EnumConstant) right).Child;
} else if (left is EnumConstant && rt == lt) {
switch (oper){
///
/// E operator |(E x, E y);
/// E operator &(E x, E y);
/// E operator ^(E x, E y);
///
case Binary.Operator.BitwiseOr:
case Binary.Operator.BitwiseAnd:
case Binary.Operator.ExclusiveOr:
result = BinaryFold (ec, oper, ((EnumConstant)left).Child, ((EnumConstant)right).Child, loc);
if (result != null)
result = result.Reduce (ec, lt);
return result;
///
/// U operator -(E x, E y);
///
case Binary.Operator.Subtraction:
result = BinaryFold (ec, oper, ((EnumConstant)left).Child, ((EnumConstant)right).Child, loc);
if (result != null)
result = result.Reduce (ec, EnumSpec.GetUnderlyingType (lt));
return result;
///
/// bool operator ==(E x, E y);
/// bool operator !=(E x, E y);
/// bool operator <(E x, E y);
/// bool operator >(E x, E y);
/// bool operator <=(E x, E y);
/// bool operator >=(E x, E y);
///
case Binary.Operator.Equality:
case Binary.Operator.Inequality:
case Binary.Operator.LessThan:
case Binary.Operator.GreaterThan:
case Binary.Operator.LessThanOrEqual:
case Binary.Operator.GreaterThanOrEqual:
return BinaryFold(ec, oper, ((EnumConstant)left).Child, ((EnumConstant)right).Child, loc);
}
return null;
}
switch (oper){
case Binary.Operator.BitwiseOr:
//
// bool? operator |(bool? x, bool? y);
//
if ((lt.BuiltinType == BuiltinTypeSpec.Type.Bool && right is NullLiteral) ||
(rt.BuiltinType == BuiltinTypeSpec.Type.Bool && left is NullLiteral)) {
var b = new Binary (oper, left, right).ResolveOperator (ec);
// false | null => null
// null | false => null
if ((right is NullLiteral && left.IsDefaultValue) || (left is NullLiteral && right.IsDefaultValue))
return Nullable.LiftedNull.CreateFromExpression (ec, b);
// true | null => true
// null | true => true
return ReducedExpression.Create (new BoolConstant (ec.BuiltinTypes, true, loc), b);
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
if (left is IntConstant){
int res = ((IntConstant) left).Value | ((IntConstant) right).Value;
return new IntConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is UIntConstant){
uint res = ((UIntConstant)left).Value | ((UIntConstant)right).Value;
return new UIntConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is LongConstant){
long res = ((LongConstant)left).Value | ((LongConstant)right).Value;
return new LongConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is ULongConstant){
ulong res = ((ULongConstant)left).Value |
((ULongConstant)right).Value;
return new ULongConstant (ec.BuiltinTypes, res, left.Location);
}
break;
case Binary.Operator.BitwiseAnd:
//
// bool? operator &(bool? x, bool? y);
//
if ((lt.BuiltinType == BuiltinTypeSpec.Type.Bool && right is NullLiteral) ||
(rt.BuiltinType == BuiltinTypeSpec.Type.Bool && left is NullLiteral)) {
var b = new Binary (oper, left, right).ResolveOperator (ec);
// false & null => false
// null & false => false
if ((right is NullLiteral && left.IsDefaultValue) || (left is NullLiteral && right.IsDefaultValue))
return ReducedExpression.Create (new BoolConstant (ec.BuiltinTypes, false, loc), b);
// true & null => null
// null & true => null
return Nullable.LiftedNull.CreateFromExpression (ec, b);
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
///
/// int operator &(int x, int y);
/// uint operator &(uint x, uint y);
/// long operator &(long x, long y);
/// ulong operator &(ulong x, ulong y);
///
if (left is IntConstant){
int res = ((IntConstant) left).Value & ((IntConstant) right).Value;
return new IntConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is UIntConstant){
uint res = ((UIntConstant)left).Value & ((UIntConstant)right).Value;
return new UIntConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is LongConstant){
long res = ((LongConstant)left).Value & ((LongConstant)right).Value;
return new LongConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is ULongConstant){
ulong res = ((ULongConstant)left).Value &
((ULongConstant)right).Value;
return new ULongConstant (ec.BuiltinTypes, res, left.Location);
}
break;
case Binary.Operator.ExclusiveOr:
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
if (left is IntConstant){
int res = ((IntConstant) left).Value ^ ((IntConstant) right).Value;
return new IntConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is UIntConstant){
uint res = ((UIntConstant)left).Value ^ ((UIntConstant)right).Value;
return new UIntConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is LongConstant){
long res = ((LongConstant)left).Value ^ ((LongConstant)right).Value;
return new LongConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is ULongConstant){
ulong res = ((ULongConstant)left).Value ^
((ULongConstant)right).Value;
return new ULongConstant (ec.BuiltinTypes, res, left.Location);
}
break;
case Binary.Operator.Addition:
//
// If both sides are strings, then concatenate
//
// string operator + (string x, string y)
//
if (lt.BuiltinType == BuiltinTypeSpec.Type.String || rt.BuiltinType == BuiltinTypeSpec.Type.String){
if (lt == rt)
return new StringConstant (ec.BuiltinTypes, (string)left.GetValue () + (string)right.GetValue (),
left.Location);
if (lt == InternalType.NullLiteral || left.IsNull)
return new StringConstant (ec.BuiltinTypes, "" + right.GetValue (), left.Location);
if (rt == InternalType.NullLiteral || right.IsNull)
return new StringConstant (ec.BuiltinTypes, left.GetValue () + "", left.Location);
return null;
}
//
// string operator + (string x, object y)
//
if (lt == InternalType.NullLiteral) {
if (rt.BuiltinType == BuiltinTypeSpec.Type.Object)
return new StringConstant (ec.BuiltinTypes, "" + right.GetValue (), left.Location);
if (lt == rt) {
ec.Report.Error (34, loc, "Operator `{0}' is ambiguous on operands of type `{1}' and `{2}'",
"+", lt.GetSignatureForError (), rt.GetSignatureForError ());
return null;
}
return right;
}
//
// string operator + (object x, string y)
//
if (rt == InternalType.NullLiteral) {
if (lt.BuiltinType == BuiltinTypeSpec.Type.Object)
return new StringConstant (ec.BuiltinTypes, right.GetValue () + "", left.Location);
return left;
}
//
// handle "E operator + (E x, U y)"
// handle "E operator + (Y y, E x)"
//
EnumConstant lc = left as EnumConstant;
EnumConstant rc = right as EnumConstant;
if (lc != null || rc != null){
if (lc == null) {
lc = rc;
lt = lc.Type;
right = left;
}
// U has to be implicitly convetible to E.base
right = right.ConvertImplicitly (lc.Child.Type);
if (right == null)
return null;
result = BinaryFold (ec, oper, lc.Child, right, loc);
if (result == null)
return null;
result = result.Reduce (ec, lt);
if (result == null || lt.IsEnum)
return result;
return new EnumConstant (result, lt);
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
try {
if (left is DoubleConstant){
double res;
if (ec.ConstantCheckState)
res = checked (((DoubleConstant) left).Value +
((DoubleConstant) right).Value);
else
res = unchecked (((DoubleConstant) left).Value +
((DoubleConstant) right).Value);
return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is FloatConstant){
double a, b, res;
a = ((FloatConstant) left).DoubleValue;
b = ((FloatConstant) right).DoubleValue;
if (ec.ConstantCheckState)
res = checked (a + b);
else
res = unchecked (a + b);
result = new FloatConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is ULongConstant){
ulong res;
if (ec.ConstantCheckState)
res = checked (((ULongConstant) left).Value +
((ULongConstant) right).Value);
else
res = unchecked (((ULongConstant) left).Value +
((ULongConstant) right).Value);
result = new ULongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is LongConstant){
long res;
if (ec.ConstantCheckState)
res = checked (((LongConstant) left).Value +
((LongConstant) right).Value);
else
res = unchecked (((LongConstant) left).Value +
((LongConstant) right).Value);
result = new LongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is UIntConstant){
uint res;
if (ec.ConstantCheckState)
res = checked (((UIntConstant) left).Value +
((UIntConstant) right).Value);
else
res = unchecked (((UIntConstant) left).Value +
((UIntConstant) right).Value);
result = new UIntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is IntConstant){
int res;
if (ec.ConstantCheckState)
res = checked (((IntConstant) left).Value +
((IntConstant) right).Value);
else
res = unchecked (((IntConstant) left).Value +
((IntConstant) right).Value);
result = new IntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is DecimalConstant) {
decimal res;
if (ec.ConstantCheckState)
res = checked (((DecimalConstant) left).Value +
((DecimalConstant) right).Value);
else
res = unchecked (((DecimalConstant) left).Value +
((DecimalConstant) right).Value);
result = new DecimalConstant (ec.BuiltinTypes, res, left.Location);
}
} catch (OverflowException){
Error_CompileTimeOverflow (ec, loc);
}
return result;
case Binary.Operator.Subtraction:
//
// handle "E operator - (E x, U y)"
// handle "E operator - (Y y, E x)"
//
lc = left as EnumConstant;
rc = right as EnumConstant;
if (lc != null || rc != null){
if (lc == null) {
lc = rc;
lt = lc.Type;
right = left;
}
// U has to be implicitly convetible to E.base
right = right.ConvertImplicitly (lc.Child.Type);
if (right == null)
return null;
result = BinaryFold (ec, oper, lc.Child, right, loc);
if (result == null)
return null;
result = result.Reduce (ec, lt);
if (result == null)
return null;
return new EnumConstant (result, lt);
}
if (left is NullLiteral && right is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
try {
if (left is DoubleConstant){
double res;
if (ec.ConstantCheckState)
res = checked (((DoubleConstant) left).Value -
((DoubleConstant) right).Value);
else
res = unchecked (((DoubleConstant) left).Value -
((DoubleConstant) right).Value);
result = new DoubleConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is FloatConstant){
double a, b, res;
a = ((FloatConstant) left).DoubleValue;
b = ((FloatConstant) right).DoubleValue;
if (ec.ConstantCheckState)
res = checked (a - b);
else
res = unchecked (a - b);
result = new FloatConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is ULongConstant){
ulong res;
if (ec.ConstantCheckState)
res = checked (((ULongConstant) left).Value -
((ULongConstant) right).Value);
else
res = unchecked (((ULongConstant) left).Value -
((ULongConstant) right).Value);
result = new ULongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is LongConstant){
long res;
if (ec.ConstantCheckState)
res = checked (((LongConstant) left).Value -
((LongConstant) right).Value);
else
res = unchecked (((LongConstant) left).Value -
((LongConstant) right).Value);
result = new LongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is UIntConstant){
uint res;
if (ec.ConstantCheckState)
res = checked (((UIntConstant) left).Value -
((UIntConstant) right).Value);
else
res = unchecked (((UIntConstant) left).Value -
((UIntConstant) right).Value);
result = new UIntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is IntConstant){
int res;
if (ec.ConstantCheckState)
res = checked (((IntConstant) left).Value -
((IntConstant) right).Value);
else
res = unchecked (((IntConstant) left).Value -
((IntConstant) right).Value);
result = new IntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is DecimalConstant) {
decimal res;
if (ec.ConstantCheckState)
res = checked (((DecimalConstant) left).Value -
((DecimalConstant) right).Value);
else
res = unchecked (((DecimalConstant) left).Value -
((DecimalConstant) right).Value);
return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
} else {
throw new Exception ( "Unexepected subtraction input: " + left);
}
} catch (OverflowException){
Error_CompileTimeOverflow (ec, loc);
}
return result;
case Binary.Operator.Multiply:
if (left is NullLiteral && right is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
try {
if (left is DoubleConstant){
double res;
if (ec.ConstantCheckState)
res = checked (((DoubleConstant) left).Value *
((DoubleConstant) right).Value);
else
res = unchecked (((DoubleConstant) left).Value *
((DoubleConstant) right).Value);
return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is FloatConstant){
double a, b, res;
a = ((FloatConstant) left).DoubleValue;
b = ((FloatConstant) right).DoubleValue;
if (ec.ConstantCheckState)
res = checked (a * b);
else
res = unchecked (a * b);
return new FloatConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is ULongConstant){
ulong res;
if (ec.ConstantCheckState)
res = checked (((ULongConstant) left).Value *
((ULongConstant) right).Value);
else
res = unchecked (((ULongConstant) left).Value *
((ULongConstant) right).Value);
return new ULongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is LongConstant){
long res;
if (ec.ConstantCheckState)
res = checked (((LongConstant) left).Value *
((LongConstant) right).Value);
else
res = unchecked (((LongConstant) left).Value *
((LongConstant) right).Value);
return new LongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is UIntConstant){
uint res;
if (ec.ConstantCheckState)
res = checked (((UIntConstant) left).Value *
((UIntConstant) right).Value);
else
res = unchecked (((UIntConstant) left).Value *
((UIntConstant) right).Value);
return new UIntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is IntConstant){
int res;
if (ec.ConstantCheckState)
res = checked (((IntConstant) left).Value *
((IntConstant) right).Value);
else
res = unchecked (((IntConstant) left).Value *
((IntConstant) right).Value);
return new IntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is DecimalConstant) {
decimal res;
if (ec.ConstantCheckState)
res = checked (((DecimalConstant) left).Value *
((DecimalConstant) right).Value);
else
res = unchecked (((DecimalConstant) left).Value *
((DecimalConstant) right).Value);
return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
} else {
throw new Exception ( "Unexepected multiply input: " + left);
}
} catch (OverflowException){
Error_CompileTimeOverflow (ec, loc);
}
break;
case Binary.Operator.Division:
if (left is NullLiteral && right is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
try {
if (left is DoubleConstant){
double res;
if (ec.ConstantCheckState)
res = checked (((DoubleConstant) left).Value /
((DoubleConstant) right).Value);
else
res = unchecked (((DoubleConstant) left).Value /
((DoubleConstant) right).Value);
return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is FloatConstant){
double a, b, res;
a = ((FloatConstant) left).DoubleValue;
b = ((FloatConstant) right).DoubleValue;
if (ec.ConstantCheckState)
res = checked (a / b);
else
res = unchecked (a / b);
return new FloatConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is ULongConstant){
ulong res;
if (ec.ConstantCheckState)
res = checked (((ULongConstant) left).Value /
((ULongConstant) right).Value);
else
res = unchecked (((ULongConstant) left).Value /
((ULongConstant) right).Value);
return new ULongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is LongConstant){
long res;
if (ec.ConstantCheckState)
res = checked (((LongConstant) left).Value /
((LongConstant) right).Value);
else
res = unchecked (((LongConstant) left).Value /
((LongConstant) right).Value);
return new LongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is UIntConstant){
uint res;
if (ec.ConstantCheckState)
res = checked (((UIntConstant) left).Value /
((UIntConstant) right).Value);
else
res = unchecked (((UIntConstant) left).Value /
((UIntConstant) right).Value);
return new UIntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is IntConstant){
int res;
if (ec.ConstantCheckState)
res = checked (((IntConstant) left).Value /
((IntConstant) right).Value);
else
res = unchecked (((IntConstant) left).Value /
((IntConstant) right).Value);
return new IntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is DecimalConstant) {
decimal res;
if (ec.ConstantCheckState)
res = checked (((DecimalConstant) left).Value /
((DecimalConstant) right).Value);
else
res = unchecked (((DecimalConstant) left).Value /
((DecimalConstant) right).Value);
return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
} else {
throw new Exception ( "Unexepected division input: " + left);
}
} catch (OverflowException){
Error_CompileTimeOverflow (ec, loc);
} catch (DivideByZeroException) {
ec.Report.Error (20, loc, "Division by constant zero");
}
break;
case Binary.Operator.Modulus:
if (left is NullLiteral && right is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
try {
if (left is DoubleConstant){
double res;
if (ec.ConstantCheckState)
res = checked (((DoubleConstant) left).Value %
((DoubleConstant) right).Value);
else
res = unchecked (((DoubleConstant) left).Value %
((DoubleConstant) right).Value);
return new DoubleConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is FloatConstant){
double a, b, res;
a = ((FloatConstant) left).DoubleValue;
b = ((FloatConstant) right).DoubleValue;
if (ec.ConstantCheckState)
res = checked (a % b);
else
res = unchecked (a % b);
return new FloatConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is ULongConstant){
ulong res;
if (ec.ConstantCheckState)
res = checked (((ULongConstant) left).Value %
((ULongConstant) right).Value);
else
res = unchecked (((ULongConstant) left).Value %
((ULongConstant) right).Value);
return new ULongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is LongConstant){
long res;
if (ec.ConstantCheckState)
res = checked (((LongConstant) left).Value %
((LongConstant) right).Value);
else
res = unchecked (((LongConstant) left).Value %
((LongConstant) right).Value);
return new LongConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is UIntConstant){
uint res;
if (ec.ConstantCheckState)
res = checked (((UIntConstant) left).Value %
((UIntConstant) right).Value);
else
res = unchecked (((UIntConstant) left).Value %
((UIntConstant) right).Value);
return new UIntConstant (ec.BuiltinTypes, res, left.Location);
} else if (left is IntConstant){
int res;
if (ec.ConstantCheckState)
res = checked (((IntConstant) left).Value %
((IntConstant) right).Value);
else
res = unchecked (((IntConstant) left).Value %
((IntConstant) right).Value);
return new IntConstant (ec.BuiltinTypes, res, left.Location);
}
if (left is DecimalConstant) {
decimal res;
if (ec.ConstantCheckState)
res = checked (((DecimalConstant) left).Value %
((DecimalConstant) right).Value);
else
res = unchecked (((DecimalConstant) left).Value %
((DecimalConstant) right).Value);
return new DecimalConstant (ec.BuiltinTypes, res, left.Location);
}
throw new Exception ( "Unexepected modulus input: " + left);
} catch (DivideByZeroException){
ec.Report.Error (20, loc, "Division by constant zero");
} catch (OverflowException){
Error_CompileTimeOverflow (ec, loc);
}
break;
//
// There is no overflow checking on left shift
//
case Binary.Operator.LeftShift:
if (left is NullLiteral && right is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
IntConstant ic = right.ConvertImplicitly (ec.BuiltinTypes.Int) as IntConstant;
if (ic == null){
return null;
}
int lshift_val = ic.Value;
switch (left.Type.BuiltinType) {
case BuiltinTypeSpec.Type.ULong:
return new ULongConstant (ec.BuiltinTypes, ((ULongConstant) left).Value << lshift_val, left.Location);
case BuiltinTypeSpec.Type.Long:
return new LongConstant (ec.BuiltinTypes, ((LongConstant) left).Value << lshift_val, left.Location);
case BuiltinTypeSpec.Type.UInt:
return new UIntConstant (ec.BuiltinTypes, ((UIntConstant) left).Value << lshift_val, left.Location);
}
// null << value => null
if (left is NullLiteral)
return (Constant) new Binary (oper, left, right).ResolveOperator (ec);
left = left.ConvertImplicitly (ec.BuiltinTypes.Int);
if (left.Type.BuiltinType == BuiltinTypeSpec.Type.Int)
return new IntConstant (ec.BuiltinTypes, ((IntConstant) left).Value << lshift_val, left.Location);
return null;
//
// There is no overflow checking on right shift
//
case Binary.Operator.RightShift:
if (left is NullLiteral && right is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
IntConstant sic = right.ConvertImplicitly (ec.BuiltinTypes.Int) as IntConstant;
if (sic == null){
return null;
}
int rshift_val = sic.Value;
switch (left.Type.BuiltinType) {
case BuiltinTypeSpec.Type.ULong:
return new ULongConstant (ec.BuiltinTypes, ((ULongConstant) left).Value >> rshift_val, left.Location);
case BuiltinTypeSpec.Type.Long:
return new LongConstant (ec.BuiltinTypes, ((LongConstant) left).Value >> rshift_val, left.Location);
case BuiltinTypeSpec.Type.UInt:
return new UIntConstant (ec.BuiltinTypes, ((UIntConstant) left).Value >> rshift_val, left.Location);
}
// null >> value => null
if (left is NullLiteral)
return (Constant) new Binary (oper, left, right).ResolveOperator (ec);
left = left.ConvertImplicitly (ec.BuiltinTypes.Int);
if (left.Type.BuiltinType == BuiltinTypeSpec.Type.Int)
return new IntConstant (ec.BuiltinTypes, ((IntConstant) left).Value >> rshift_val, left.Location);
return null;
case Binary.Operator.Equality:
if (TypeSpec.IsReferenceType (lt) && TypeSpec.IsReferenceType (rt) ||
(left is Nullable.LiftedNull && right.IsNull) ||
(right is Nullable.LiftedNull && left.IsNull)) {
if (left.IsNull || right.IsNull) {
return ReducedExpression.Create (
new BoolConstant (ec.BuiltinTypes, left.IsNull == right.IsNull, left.Location),
new Binary (oper, left, right));
}
if (left is StringConstant && right is StringConstant)
return new BoolConstant (ec.BuiltinTypes,
((StringConstant) left).Value == ((StringConstant) right).Value, left.Location);
return null;
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
bool_res = false;
if (left is DoubleConstant)
bool_res = ((DoubleConstant) left).Value ==
((DoubleConstant) right).Value;
else if (left is FloatConstant)
bool_res = ((FloatConstant) left).DoubleValue ==
((FloatConstant) right).DoubleValue;
else if (left is ULongConstant)
bool_res = ((ULongConstant) left).Value ==
((ULongConstant) right).Value;
else if (left is LongConstant)
bool_res = ((LongConstant) left).Value ==
((LongConstant) right).Value;
else if (left is UIntConstant)
bool_res = ((UIntConstant) left).Value ==
((UIntConstant) right).Value;
else if (left is IntConstant)
bool_res = ((IntConstant) left).Value ==
((IntConstant) right).Value;
else
return null;
return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
case Binary.Operator.Inequality:
if (TypeSpec.IsReferenceType (lt) && TypeSpec.IsReferenceType (rt) ||
(left is Nullable.LiftedNull && right.IsNull) ||
(right is Nullable.LiftedNull && left.IsNull)) {
if (left.IsNull || right.IsNull) {
return ReducedExpression.Create (
new BoolConstant (ec.BuiltinTypes, left.IsNull != right.IsNull, left.Location),
new Binary (oper, left, right));
}
if (left is StringConstant && right is StringConstant)
return new BoolConstant (ec.BuiltinTypes,
((StringConstant) left).Value != ((StringConstant) right).Value, left.Location);
return null;
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
bool_res = false;
if (left is DoubleConstant)
bool_res = ((DoubleConstant) left).Value !=
((DoubleConstant) right).Value;
else if (left is FloatConstant)
bool_res = ((FloatConstant) left).DoubleValue !=
((FloatConstant) right).DoubleValue;
else if (left is ULongConstant)
bool_res = ((ULongConstant) left).Value !=
((ULongConstant) right).Value;
else if (left is LongConstant)
bool_res = ((LongConstant) left).Value !=
((LongConstant) right).Value;
else if (left is UIntConstant)
bool_res = ((UIntConstant) left).Value !=
((UIntConstant) right).Value;
else if (left is IntConstant)
bool_res = ((IntConstant) left).Value !=
((IntConstant) right).Value;
else
return null;
return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
case Binary.Operator.LessThan:
if (right is NullLiteral) {
if (left is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
bool_res = false;
if (left is DoubleConstant)
bool_res = ((DoubleConstant) left).Value <
((DoubleConstant) right).Value;
else if (left is FloatConstant)
bool_res = ((FloatConstant) left).DoubleValue <
((FloatConstant) right).DoubleValue;
else if (left is ULongConstant)
bool_res = ((ULongConstant) left).Value <
((ULongConstant) right).Value;
else if (left is LongConstant)
bool_res = ((LongConstant) left).Value <
((LongConstant) right).Value;
else if (left is UIntConstant)
bool_res = ((UIntConstant) left).Value <
((UIntConstant) right).Value;
else if (left is IntConstant)
bool_res = ((IntConstant) left).Value <
((IntConstant) right).Value;
else
return null;
return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
case Binary.Operator.GreaterThan:
if (right is NullLiteral) {
if (left is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
bool_res = false;
if (left is DoubleConstant)
bool_res = ((DoubleConstant) left).Value >
((DoubleConstant) right).Value;
else if (left is FloatConstant)
bool_res = ((FloatConstant) left).DoubleValue >
((FloatConstant) right).DoubleValue;
else if (left is ULongConstant)
bool_res = ((ULongConstant) left).Value >
((ULongConstant) right).Value;
else if (left is LongConstant)
bool_res = ((LongConstant) left).Value >
((LongConstant) right).Value;
else if (left is UIntConstant)
bool_res = ((UIntConstant) left).Value >
((UIntConstant) right).Value;
else if (left is IntConstant)
bool_res = ((IntConstant) left).Value >
((IntConstant) right).Value;
else
return null;
return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
case Binary.Operator.GreaterThanOrEqual:
if (right is NullLiteral) {
if (left is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
bool_res = false;
if (left is DoubleConstant)
bool_res = ((DoubleConstant) left).Value >=
((DoubleConstant) right).Value;
else if (left is FloatConstant)
bool_res = ((FloatConstant) left).DoubleValue >=
((FloatConstant) right).DoubleValue;
else if (left is ULongConstant)
bool_res = ((ULongConstant) left).Value >=
((ULongConstant) right).Value;
else if (left is LongConstant)
bool_res = ((LongConstant) left).Value >=
((LongConstant) right).Value;
else if (left is UIntConstant)
bool_res = ((UIntConstant) left).Value >=
((UIntConstant) right).Value;
else if (left is IntConstant)
bool_res = ((IntConstant) left).Value >=
((IntConstant) right).Value;
else
return null;
return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
case Binary.Operator.LessThanOrEqual:
if (right is NullLiteral) {
if (left is NullLiteral) {
var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
lifted_int.ResolveAsType (ec);
return (Constant) new Binary (oper, lifted_int, right).ResolveOperator (ec);
}
}
if (!DoBinaryNumericPromotions (ec, ref left, ref right))
return null;
bool_res = false;
if (left is DoubleConstant)
bool_res = ((DoubleConstant) left).Value <=
((DoubleConstant) right).Value;
else if (left is FloatConstant)
bool_res = ((FloatConstant) left).DoubleValue <=
((FloatConstant) right).DoubleValue;
else if (left is ULongConstant)
bool_res = ((ULongConstant) left).Value <=
((ULongConstant) right).Value;
else if (left is LongConstant)
bool_res = ((LongConstant) left).Value <=
((LongConstant) right).Value;
else if (left is UIntConstant)
bool_res = ((UIntConstant) left).Value <=
((UIntConstant) right).Value;
else if (left is IntConstant)
bool_res = ((IntConstant) left).Value <=
((IntConstant) right).Value;
else
return null;
return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
}
return null;
}
protected override Expression DoResolve(ResolveContext rc)
{
var sn = expr as SimpleName;
const ResolveFlags flags = ResolveFlags.VariableOrValue | ResolveFlags.Type;
if (sn != null)
{
expr = sn.LookupNameExpression(rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity);
//
// Resolve expression which does have type set as we need expression type
// with disable flow analysis as we don't know whether left side expression
// is used as variable or type
//
if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess)
{
expr = expr.Resolve(rc);
}
else if (expr is TypeParameterExpr)
{
expr.Error_UnexpectedKind(rc, flags, sn.Location);
expr = null;
}
}
else
{
expr = expr.Resolve(rc, flags);
}
if (expr == null)
{
return(null);
}
TypeSpec expr_type = expr.Type;
if (expr_type.IsPointer || expr_type.Kind == MemberKind.Void || expr_type == InternalType.NullLiteral || expr_type == InternalType.AnonymousMethod)
{
expr.Error_OperatorCannotBeApplied(rc, loc, ".", expr_type);
return(null);
}
if (targs != null)
{
if (!targs.Resolve(rc, true))
{
return(null);
}
}
var results = new List <string> ();
var nexpr = expr as NamespaceExpression;
if (nexpr != null)
{
string namespaced_partial;
if (partial_name == null)
{
namespaced_partial = nexpr.Namespace.Name;
}
else
{
namespaced_partial = nexpr.Namespace.Name + "." + partial_name;
}
rc.CurrentMemberDefinition.GetCompletionStartingWith(namespaced_partial, results);
if (partial_name != null)
{
results = results.Select(l => l.Substring(partial_name.Length)).ToList();
}
}
else
{
var r = MemberCache.GetCompletitionMembers(rc, expr_type, partial_name).Select(l => l.Name);
AppendResults(results, partial_name, r);
}
throw new CompletionResult(partial_name == null ? "" : partial_name, results.Distinct().ToArray());
}