private void EatOptionValue(ISnapshot snapshot, ExpressionKind kind, ICSharpExpression optionValue)
{
var addableKinds = new[] { ExpressionKind.Target, ExpressionKind.Stub, ExpressionKind.Mock };
if (addableKinds.Contains(kind))
{
snapshot.Add(kind, optionValue);
}
}
public ExpressionKind ReferenceKindByParentReferenceKindTest(ExpressionKind kind)
{
// Arrange
var helper = new ExpressionKindHelper();
// Assert
return helper.ReferenceKindByParentReferenceKind(kind);
}
public ExpressionKind KindOfAssignmentTest(ExpressionKind kind)
{
// Arrange
var helper = new ExpressionKindHelper();
// Assert
return helper.KindOfAssignment(kind);
}
public EXPRUNARYOP CreateUnaryOp(ExpressionKind exprKind, CType pType, EXPR pOperand)
{
Debug.Assert(exprKind.isUnaryOperator());
Debug.Assert(pOperand != null);
EXPRUNARYOP rval = new EXPRUNARYOP();
rval.kind = exprKind;
rval.type = pType;
rval.flags = 0;
rval.Child = pOperand;
rval.OptionalUserDefinedCall = null;
rval.UserDefinedCallMethod = null;
Debug.Assert(rval != null);
return(rval);
}
private bool TryNameByToMethod(string methodName, ExpressionKind expressionKind)
{
int index = methodName.IndexOf("To", 0);
while (index >= 0)
{
if ((index + 2 < methodName.Length) && (char.IsUpper(methodName[index + 2])))
{
SuggestNameForMethod(expressionKind, methodName, index + 2);
return(true);
}
index = methodName.IndexOf("To", index + 1);
}
return(false);
}
public ExprUnaryOp CreateUnaryOp(ExpressionKind exprKind, CType pType, Expr pOperand)
{
Debug.Assert(exprKind.isUnaryOperator());
Debug.Assert(pOperand != null);
ExprUnaryOp rval = new ExprUnaryOp();
rval.Kind = exprKind;
rval.Type = pType;
rval.Flags = 0;
rval.Child = pOperand;
rval.OptionalUserDefinedCall = null;
rval.UserDefinedCallMethod = null;
Debug.Assert(rval != null);
return(rval);
}
public ExpressionKind RetrunKindTest(ExpressionKind leftKind, ExpressionKind rightKind)
{
// Arrange
var snapshot = Mock.Of <ISnapshot>();
var left = Mock.Of <ICSharpExpression>();
var right = Mock.Of <ICSharpExpression>();
var binaryExpression = Mock.Of <IBinaryExpression>(t => t.LeftOperand == left && t.RightOperand == right);
var eater = Mock.Of <IEater>(t => t.Eat(snapshot, left) == leftKind &&
t.Eat(snapshot, right) == rightKind);
var binaryExpressionEater = new BinaryExpressionEater(eater);
// Assert
return(binaryExpressionEater.Eat(snapshot, binaryExpression));
}
/// <summary>
/// Creates an operation call from the conditional control API, given information
/// about which operation to call and with what arguments.
/// </summary>
private TypedExpression CreateControlCall(BuiltIn opInfo, IEnumerable <OpProperty> properties, TypedExpression args, IEnumerable <ResolvedType> typeArgs)
{
var characteristics = new CallableInformation(
ResolvedCharacteristics.FromProperties(properties),
new InferredCallableInformation(((BuiltInKind.Operation)opInfo.Kind).IsSelfAdjoint, false));
var unitType = ResolvedType.New(ResolvedTypeKind.UnitType);
var operationType = ResolvedType.New(ResolvedTypeKind.NewOperation(
Tuple.Create(args.ResolvedType, unitType),
characteristics));
// Build the surrounding control call
var identifier = new TypedExpression(
ExpressionKind.NewIdentifier(
Identifier.NewGlobalCallable(opInfo.FullName),
typeArgs.Any()
? QsNullable <ImmutableArray <ResolvedType> > .NewValue(typeArgs.ToImmutableArray())
: QsNullable <ImmutableArray <ResolvedType> > .Null),
typeArgs
.Zip(((BuiltInKind.Operation)opInfo.Kind).TypeParameters, (type, param) => Tuple.Create(opInfo.FullName, param, type))
.ToImmutableArray(),
operationType,
new InferredExpressionInformation(false, false),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null);
// Creates type resolutions for the call expression
var opTypeArgResolutions = typeArgs
.SelectMany(x =>
x.Resolution is ResolvedTypeKind.TupleType tup
? tup.Item
: ImmutableArray.Create(x))
.Where(x => x.Resolution.IsTypeParameter)
.Select(x => (x.Resolution as ResolvedTypeKind.TypeParameter).Item)
.GroupBy(x => (x.Origin, x.TypeName))
.Select(group =>
{
var typeParam = group.First();
return(Tuple.Create(typeParam.Origin, typeParam.TypeName, ResolvedType.New(ResolvedTypeKind.NewTypeParameter(typeParam))));
})
.ToImmutableArray();
return(new TypedExpression(
ExpressionKind.NewCallLikeExpression(identifier, args),
opTypeArgResolutions,
unitType,
new InferredExpressionInformation(false, true),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null));
}
public override ExpressionKind Eat(ISnapshot snapshot, IArrayCreationExpression expression)
{
// TODO : check in functional tests
foreach (ICSharpExpression size in expression.Sizes)
{
ExpressionKind kind = Eater.Eat(snapshot, size);
if (kind != ExpressionKind.StubCandidate)
{
snapshot.Add(kind, size);
}
}
_variableInitializerEater.Eat(snapshot, expression.ArrayInitializer);
return(ExpressionKind.StubCandidate);
}
internal static TypedExpression CreateIdentifierExpression(Identifier id,
TypeArgsResolution typeArgsMapping, ResolvedType resolvedType) =>
new TypedExpression
(
ExpressionKind.NewIdentifier(
id,
typeArgsMapping.Any()
? QsNullable <ImmutableArray <ResolvedType> > .NewValue(typeArgsMapping
.Select(argMapping => argMapping.Item3) // This should preserve the order of the type args
.ToImmutableArray())
: QsNullable <ImmutableArray <ResolvedType> > .Null),
typeArgsMapping,
resolvedType,
new InferredExpressionInformation(false, false),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null
);
private ExpressionKind EatResults(ISnapshot snapshot, ICSharpExpression initialExpression)
{
ExpressionKind expressionKind = _eater.Eat(snapshot, initialExpression);
if (expressionKind == ExpressionKind.StubCandidate)
{
return(ExpressionKind.Stub);
}
if (expressionKind == ExpressionKind.TargetCall)
{
return(ExpressionKind.Result);
}
return(expressionKind);
}
public ExprBinOp CreateBinop(ExpressionKind exprKind, CType pType, Expr p1, Expr p2)
{
//Debug.Assert(exprKind.isBinaryOperator());
ExprBinOp rval = new ExprBinOp();
rval.Kind = exprKind;
rval.Type = pType;
rval.Flags = EXPRFLAG.EXF_BINOP;
rval.OptionalLeftChild = p1;
rval.OptionalRightChild = p2;
rval.IsLifted = false;
rval.OptionalUserDefinedCall = null;
rval.UserDefinedCallMethod = null;
Debug.Assert(rval != null);
return(rval);
}
public virtual ExpressionKind InvocationKindByParentReferenceKind(ExpressionKind parentKind)
{
switch (parentKind)
{
case ExpressionKind.TargetCall:
{
return ExpressionKind.Result;
}
case ExpressionKind.Target:
{
return ExpressionKind.TargetCall;
}
}
return parentKind;
}
public EXPRBINOP CreateBinop(ExpressionKind exprKind, CType pType, EXPR p1, EXPR p2)
{
//Debug.Assert(exprKind.isBinaryOperator());
EXPRBINOP rval = new EXPRBINOP();
rval.kind = exprKind;
rval.type = pType;
rval.flags = EXPRFLAG.EXF_BINOP;
rval.SetOptionalLeftChild(p1);
rval.SetOptionalRightChild(p2);
rval.isLifted = false;
rval.SetOptionalUserDefinedCall(null);
rval.SetUserDefinedCallMethod(null);
Debug.Assert(rval != null);
return(rval);
}
public virtual ExpressionKind InvocationKindByParentReferenceKind(ExpressionKind parentKind)
{
switch (parentKind)
{
case ExpressionKind.TargetCall:
{
return(ExpressionKind.Result);
}
case ExpressionKind.Target:
{
return(ExpressionKind.TargetCall);
}
}
return(parentKind);
}
public void AddLocalVariableToSnapshotTest(ExpressionKind initKind, ExpressionKind variableKindMustBe)
{
// Arrange
var snapshot = new Mock <ISnapshot>();
var initializer = Mock.Of <IVariableInitializer>();
var localConstantDeclaration = Mock.Of <ILocalVariableDeclaration>(t => t.Initial == initializer);
var typeEater = Mock.Of <ITypeEater>();
var eater = Mock.Of <IEater>();
var initializerEater = Mock.Of <IVariableInitializerEater>(t => t.Eat(snapshot.Object, initializer) == initKind);
var localConstantDeclarationEater = new LocalVariableDeclarationEater(eater, initializerEater, typeEater);
// Act
localConstantDeclarationEater.Eat(snapshot.Object, localConstantDeclaration);
// Assert
snapshot.Verify(t => t.Add(variableKindMustBe, localConstantDeclaration), Times.Once);
}
public void Eat([NotNull] ISnapshot snapshot, TreeNodeCollection <ICSharpArgument> arguements)
{
if (snapshot == null)
{
throw new ArgumentNullException("snapshot");
}
foreach (ICSharpArgument arg in arguements)
{
ExpressionKind kind = _eater.Eat(snapshot, arg.Value);
if (kind != ExpressionKind.StubCandidate && !(arg.Value is IReferenceExpression))
{
snapshot.Add(kind, arg);
}
}
}
public void AddLocalVariableToSnapshotTest(ExpressionKind initKind, ExpressionKind variableKindMustBe)
{
// Arrange
var snapshot = new Mock<ISnapshot>();
var initializer = Mock.Of<IVariableInitializer>();
var localConstantDeclaration = Mock.Of<ILocalVariableDeclaration>(t => t.Initial == initializer);
var typeEater = Mock.Of<ITypeEater>();
var eater = Mock.Of<IEater>();
var initializerEater = Mock.Of<IVariableInitializerEater>(t => t.Eat(snapshot.Object, initializer) == initKind);
var localConstantDeclarationEater = new LocalVariableDeclarationEater(eater, initializerEater, typeEater);
// Act
localConstantDeclarationEater.Eat(snapshot.Object, localConstantDeclaration);
// Assert
snapshot.Verify(t => t.Add(variableKindMustBe, localConstantDeclaration), Times.Once);
}
public EXPR CreateOperator(ExpressionKind exprKind, CType pType, EXPR pArg1, EXPR pOptionalArg2)
{
Debug.Assert(pArg1 != null);
EXPR rval = null;
if (exprKind.isUnaryOperator())
{
Debug.Assert(pOptionalArg2 == null);
rval = CreateUnaryOp(exprKind, pType, pArg1);
}
else
{
rval = CreateBinop(exprKind, pType, pArg1, pOptionalArg2);
}
Debug.Assert(rval != null);
return(rval);
}
/// <remarks>
/// This method encapsulates the creation of functions with a certain number of arguments. That might be useful
/// if we want to implement internal subclasses of <see cref="Function"/> such as UnaryFunction, BinaryFunction
/// TernaryFunction and ArbitraryFunction. These might get used for the performance reasons - in order not to
/// handle an array for every function (and just for the last variant).
/// </remarks>
private static Function ArbitraryFunction(
ExpressionKind kind,
Sort sort,
Expression[] operands,
bool preserveNesting)
{
if (preserveNesting || !operands.Any(op => op.Kind == kind && op.Sort == sort))
{
return(new Function(kind, sort, operands));
}
var mergedOperands = operands
.SelectMany(op => (op.Kind == kind && op.Sort == sort) ? op.Children : Enumerable.Repeat(op, 1))
.ToArray();
return(new Function(kind, sort, mergedOperands));
}
public ExpressionKind Eat([NotNull] ISnapshot snapshot, [NotNull] IVariableInitializer initializer)
{
if (snapshot == null)
{
throw new ArgumentNullException("snapshot");
}
if (initializer == null)
{
throw new ArgumentNullException("initializer");
}
if (initializer is IArrayInitializer)
{
foreach (IVariableInitializer variableInitializer in (initializer as IArrayInitializer).ElementInitializers)
{
ExpressionKind kind = Eat(snapshot, variableInitializer);
// TODO : what if stubcandidate
snapshot.Add(kind, variableInitializer);
}
// TODO : array of target?
return(ExpressionKind.StubCandidate);
}
ICSharpExpression initialExpression = null;
if (initializer is IExpressionInitializer)
{
initialExpression = (initializer as IExpressionInitializer).Value;
}
if (initializer is IUnsafeCodeFixedPointerInitializer)
{
initialExpression = (initializer as IUnsafeCodeFixedPointerInitializer).Value;
}
if (initializer is IUnsafeCodeStackAllocInitializer)
{
initialExpression = (initializer as IUnsafeCodeStackAllocInitializer).DimExpr;
}
return(EatResults(snapshot, initialExpression));
}
public static void CheckExpression(
Expression expression,
ExpressionKind kind,
Sort sort,
string stringValue,
int?childrenCount = null)
{
Assert.AreNotEqual(null, expression);
Assert.AreEqual(kind, expression.Kind);
Assert.AreEqual(sort, expression.Sort);
Assert.AreEqual(stringValue, expression.ToString());
// TODO: Consider making it required
if (childrenCount != null)
{
Assert.AreEqual(childrenCount, expression.ChildrenCount);
}
}
private void AddAny(ExpressionKind expressionKind, ICSharpTreeNode sharpTreeNode)
{
if (expressionKind == ExpressionKind.None || expressionKind == ExpressionKind.StubCandidate)
{
return;
}
var node = SnapNodes.SingleOrDefault(t => t.Node == sharpTreeNode);
if (node == null)
{
SnapNodes.Add(new SnapNode(sharpTreeNode, expressionKind));
}
else
{
node.AddKind(expressionKind);
}
}
public ExprBinOp CreateUserDefinedBinop(ExpressionKind exprKind, CType pType, Expr p1, Expr p2, Expr call, MethPropWithInst pmpwi)
{
Debug.Assert(p1 != null);
Debug.Assert(p2 != null);
Debug.Assert(call != null);
ExprBinOp rval = new ExprBinOp(exprKind, pType);
rval.Flags = EXPRFLAG.EXF_BINOP;
rval.OptionalLeftChild = p1;
rval.OptionalRightChild = p2;
rval.OptionalUserDefinedCall = call;
rval.UserDefinedCallMethod = pmpwi;
if (call.HasError)
{
rval.SetError();
}
return(rval);
}
public void FindDeepestNode_Success(string input, int absolutePosition, ExpressionKind expectedExpressionKind, ExpressionKind?parentExpressionKind)
{
AssertParser.SucceedsWith(Parsers.Root, input, actualExpression =>
{
actualExpression.PostParse(
new TextPositions(input)
);
TestOutput.WriteLine("Actual expression:");
DumpExpression(actualExpression, currentDepth: 1);
ExpressionNode actualNodeAtPosition = actualExpression.FindDeepestNodeAt(absolutePosition);
Assert.NotNull(actualNodeAtPosition);
Assert.Equal(expectedExpressionKind, actualNodeAtPosition.Kind);
Assert.Equal(parentExpressionKind, actualNodeAtPosition.Parent?.Kind);
});
}
public ExprUnaryOp CreateUserDefinedUnaryOperator(ExpressionKind exprKind, CType pType, Expr pOperand, ExprCall call, MethPropWithInst pmpwi)
{
Debug.Assert(pType != null);
Debug.Assert(pOperand != null);
Debug.Assert(call != null);
Debug.Assert(pmpwi != null);
ExprUnaryOp rval = new ExprUnaryOp(exprKind, pType);
rval.Child = pOperand;
// The call may be lifted, but we do not mark the outer binop as lifted.
rval.OptionalUserDefinedCall = call;
rval.UserDefinedCallMethod = pmpwi;
if (call.HasError)
{
rval.SetError();
}
return(rval);
}
public virtual ExpressionKind ReferenceKindByParentReferenceKind(ExpressionKind parentKind)
{
switch (parentKind)
{
case ExpressionKind.TargetCall:
{
return ExpressionKind.Result;
}
case ExpressionKind.Target:
{
return ExpressionKind.Result;
}
case ExpressionKind.Stub:
{
return ExpressionKind.Stub;
}
case ExpressionKind.Mock:
{
return ExpressionKind.Result;
}
case ExpressionKind.StubCandidate:
{
return ExpressionKind.StubCandidate;
}
case ExpressionKind.Assert:
{
return ExpressionKind.Result;
}
case ExpressionKind.None:
{
return ExpressionKind.None;
}
case ExpressionKind.Result:
{
return ExpressionKind.Result;
}
default:
{
return ExpressionKind.None;
}
}
}
public static bool isUnaryOperator(this ExpressionKind kind)
{
switch (kind)
{
case ExpressionKind.EK_TRUE:
case ExpressionKind.EK_FALSE:
case ExpressionKind.EK_INC:
case ExpressionKind.EK_DEC:
case ExpressionKind.EK_LOGNOT:
case ExpressionKind.EK_NEG:
case ExpressionKind.EK_UPLUS:
case ExpressionKind.EK_BITNOT:
case ExpressionKind.EK_ADDR:
case ExpressionKind.EK_DECIMALNEG:
case ExpressionKind.EK_DECIMALINC:
case ExpressionKind.EK_DECIMALDEC:
return(true);
}
return(false);
}
public static bool IsUnaryOperator(this ExpressionKind kind)
{
switch (kind)
{
case ExpressionKind.True:
case ExpressionKind.False:
case ExpressionKind.Inc:
case ExpressionKind.Dec:
case ExpressionKind.LogicalNot:
case ExpressionKind.Negate:
case ExpressionKind.UnaryPlus:
case ExpressionKind.BitwiseNot:
case ExpressionKind.Addr:
case ExpressionKind.DecimalNegate:
case ExpressionKind.DecimalInc:
case ExpressionKind.DecimalDec:
return(true);
}
return(false);
}
public virtual ExpressionKind KindOfAssignment(ExpressionKind assignSourceKind)
{
switch (assignSourceKind)
{
case ExpressionKind.TargetCall:
{
return ExpressionKind.Result;
}
case ExpressionKind.StubCandidate:
{
return ExpressionKind.Stub;
}
case ExpressionKind.Assert:
{
return ExpressionKind.Result;
}
default :
{
return assignSourceKind;
}
}
}
public EXPRUNARYOP CreateUserDefinedUnaryOperator(ExpressionKind exprKind, CType pType, EXPR pOperand, EXPR call, MethPropWithInst pmpwi)
{
Debug.Assert(pType != null);
Debug.Assert(pOperand != null);
Debug.Assert(call != null);
Debug.Assert(pmpwi != null);
EXPRUNARYOP rval = new EXPRUNARYOP();
rval.kind = exprKind;
rval.type = pType;
rval.flags = 0;
rval.Child = pOperand;
// The call may be lifted, but we do not mark the outer binop as lifted.
rval.OptionalUserDefinedCall = call;
rval.UserDefinedCallMethod = pmpwi;
if (call.HasError())
{
rval.SetError();
}
Debug.Assert(rval != null);
return(rval);
}
public EXPRBINOP CreateUserDefinedBinop(ExpressionKind exprKind, CType pType, EXPR p1, EXPR p2, EXPR call, MethPropWithInst pmpwi)
{
Debug.Assert(p1 != null);
Debug.Assert(p2 != null);
Debug.Assert(call != null);
EXPRBINOP rval = new EXPRBINOP();
rval.kind = exprKind;
rval.type = pType;
rval.flags = EXPRFLAG.EXF_BINOP;
rval.SetOptionalLeftChild(p1);
rval.SetOptionalRightChild(p2);
// The call may be lifted, but we do not mark the outer binop as lifted.
rval.isLifted = false;
rval.SetOptionalUserDefinedCall(call);
rval.SetUserDefinedCallMethod(pmpwi);
if (call.HasError())
{
rval.SetError();
}
Debug.Assert(rval != null);
return(rval);
}
/// <summary>
/// Creates an array literal with the given items, setting the range information to Null.
/// If no items are given, creates an empty array of type Unit[].
/// The resolved types for all of the given expressions must match,
/// none of the given expressions should have a local quantum dependency,
/// and all range information should be stripped from each given expression.
/// </summary>
internal static TypedExpression CreateValueArray(params TypedExpression[] expressions)
{
ResolvedType type = null;
if (expressions.Any())
{
type = expressions.First().ResolvedType;
QsCompilerError.Verify(expressions.All(expr => expr.ResolvedType.Equals(type)));
}
else
{
type = ResolvedType.New(ResolvedTypeKind.UnitType);
}
return(new TypedExpression
(
ExpressionKind.NewValueArray(expressions.ToImmutableArray()),
TypeArgsResolution.Empty,
ResolvedType.New(ResolvedTypeKind.NewArrayType(type)),
new InferredExpressionInformation(false, false),
QsNullable <Tuple <QsPositionInfo, QsPositionInfo> > .Null
));
}
public ExprBinOp CreateUserDefinedBinop(ExpressionKind exprKind, CType pType, Expr p1, Expr p2, Expr call, MethPropWithInst pmpwi)
{
Debug.Assert(p1 != null);
Debug.Assert(p2 != null);
Debug.Assert(call != null);
ExprBinOp rval = new ExprBinOp();
rval.Kind = exprKind;
rval.Type = pType;
rval.Flags = EXPRFLAG.EXF_BINOP;
rval.OptionalLeftChild = p1;
rval.OptionalRightChild = p2;
// The call may be lifted, but we do not mark the outer binop as lifted.
rval.IsLifted = false;
rval.OptionalUserDefinedCall = call;
rval.UserDefinedCallMethod = pmpwi;
if (call.HasError)
{
rval.SetError();
}
Debug.Assert(rval != null);
return(rval);
}
public virtual ExpressionKind ValueOfKindAsTypeOfKind(ExpressionKind valueKind, ExpressionKind typeKind)
{
if (valueKind == ExpressionKind.TargetCall)
{
return(ExpressionKind.Result);
}
if (valueKind == ExpressionKind.Result)
{
return(ExpressionKind.Result);
}
if (valueKind == ExpressionKind.Mock)
{
return(ExpressionKind.Mock);
}
if (valueKind == ExpressionKind.Target || typeKind == ExpressionKind.Target)
{
return(ExpressionKind.Target);
}
return(valueKind);
}
public void IsExpression_Success(string testFileName, int line, int column, ExpressionKind expectedExpressionKind)
{
Position testPosition = new Position(line, column);
string testXml = LoadTestFile("TestFiles", testFileName + ".xml");
TextPositions positions = new TextPositions(testXml);
XmlDocumentSyntax document = Parser.ParseText(testXml);
XmlLocator locator = new XmlLocator(document, positions);
XmlLocation location = locator.Inspect(testPosition);
Assert.NotNull(location);
ExpressionNode actualExpression;
Range actualExpressionRange;
Assert.True(
location.IsExpression(out actualExpression, out actualExpressionRange),
"IsExpression"
);
Assert.NotNull(actualExpression);
Assert.Equal(expectedExpressionKind, actualExpression.Kind);
}
: super(ExpressionKind.Unary) {
}
: super(ExpressionKind.MethodCall, method.getReturnType()) {
: super(ExpressionKind.Literal) {
}
////////////////////////////////////////////////////////////////////////////////
// Report a bad operator types error to the user.
protected EXPR BadOperatorTypesError(ExpressionKind ek, EXPR pOperand1, EXPR pOperand2)
{
return BadOperatorTypesError(ek, pOperand1, pOperand2, null);
}
: super(ExpressionKind.Assign) {
}
protected EXPR bindUserDefinedBinOp(ExpressionKind ek, BinOpArgInfo info)
{
MethPropWithInst pmpwi = null;
if (info.pt1 <= PredefinedType.PT_ULONG && info.pt2 <= PredefinedType.PT_ULONG)
{
return null;
}
EXPR expr = null;
switch (info.binopKind)
{
case BinOpKind.Logical:
{
// Logical operators cannot be overloaded, but use the bitwise overloads.
EXPRCALL call = BindUDBinop((ExpressionKind)(ek - ExpressionKind.EK_LOGAND + ExpressionKind.EK_BITAND), info.arg1, info.arg2, true, out pmpwi);
if (call != null)
{
if (call.isOK())
{
expr = BindUserBoolOp(ek, call);
}
else
{
expr = call;
}
}
break;
}
default:
expr = BindUDBinop(ek, info.arg1, info.arg2, false, out pmpwi);
break;
}
if (expr == null)
{
return null;
}
return GetExprFactory().CreateUserDefinedBinop(ek, expr.type, info.arg1, info.arg2, expr, pmpwi);
}
protected EXPR BindStandardBinopCore(BinOpArgInfo info, BinOpFullSig bofs, ExpressionKind ek, EXPRFLAG flags)
{
if (bofs.pfn == null)
{
return BadOperatorTypesError(ek, info.arg1, info.arg2);
}
if (!bofs.isLifted() || !bofs.AutoLift())
{
EXPR expr1 = info.arg1;
EXPR expr2 = info.arg2;
if (bofs.ConvertOperandsBeforeBinding())
{
expr1 = mustConvert(expr1, bofs.Type1());
expr2 = mustConvert(expr2, bofs.Type2());
}
if (bofs.fnkind == BinOpFuncKind.BoolBitwiseOp)
{
return BindBoolBitwiseOp(ek, flags, expr1, expr2, bofs);
}
return bofs.pfn(ek, flags, expr1, expr2);
}
Debug.Assert(bofs.fnkind != BinOpFuncKind.BoolBitwiseOp);
return BindLiftedStandardBinOp(info, bofs, ek, flags);
}
private static BinaryExpression Chain(Expression left, IEnumerator<Expression> e, ExpressionKind op)
{
var right = e.Current;
return new BinaryExpression(
left : left,
op : op,
right : e.MoveNext() ? Chain(right, e, op) : right);
}
public OPINFO(TokenKind t, PredefinedName pn, ExpressionKind e, int c)
{
iToken = t;
methodName = pn;
expressionKind = e;
}
public BinaryExpression(Expression left, ExpressionKind op, Expression right)
{
Left = left;
Right = right;
Op = op;
}
public UnaryExpression(ExpressionKind op, Expression operand)
{
Operand = operand;
Op = op;
}
: super(ExpressionKind.Field, field.getType()) {
protected Name ekName(ExpressionKind ek)
{
Debug.Assert(ek >= ExpressionKind.EK_FIRSTOP && (ek - ExpressionKind.EK_FIRSTOP) < (int)s_EK2NAME.Length);
return GetSymbolLoader().GetNameManager().GetPredefName(s_EK2NAME[ek - ExpressionKind.EK_FIRSTOP]);
}
protected EXPR BadOperatorTypesError(ExpressionKind ek, EXPR pOperand1, EXPR pOperand2, CType pTypeErr)
{
// This is a hack, but we need to store the operation somewhere... the first argument's as
// good a place as any.
string strOp = pOperand1.errorString;
pOperand1 = UnwrapExpression(pOperand1);
if (pOperand1 != null)
{
if (pOperand2 != null)
{
pOperand2 = UnwrapExpression(pOperand2);
if (pOperand1.type != null &&
!pOperand1.type.IsErrorType() &&
pOperand2.type != null &&
!pOperand2.type.IsErrorType())
{
ErrorContext.Error(ErrorCode.ERR_BadBinaryOps, strOp, pOperand1.type, pOperand2.type);
}
}
else if (pOperand1.type != null && !pOperand1.type.IsErrorType())
{
ErrorContext.Error(ErrorCode.ERR_BadUnaryOp, strOp, pOperand1.type);
}
}
if (pTypeErr == null)
{
pTypeErr = GetReqPDT(PredefinedType.PT_OBJECT);
}
EXPR rval = GetExprFactory().CreateOperator(ek, pTypeErr, pOperand1, pOperand2);
rval.SetError();
return rval;
}
: super(ExpressionKind.ObjectCreation) {
this.Arguments = new ArrayList<ExpressionNode>();
}
: super(ExpressionKind.ArrayInitializer) {
this.Values = new ArrayList<ExpressionNode>();
}
: super(ExpressionKind.Cast) {
}
: super(ExpressionKind.ArrayCreation) {
this.DimensionExpressions = new ArrayList<ExpressionNode>();
}
private EXPR BindLiftedStandardBinOp(BinOpArgInfo info, BinOpFullSig bofs, ExpressionKind ek, EXPRFLAG flags)
{
Debug.Assert(bofs.Type1().IsNullableType() || bofs.Type2().IsNullableType());
EXPR arg1 = info.arg1;
EXPR arg2 = info.arg2;
// We want to get the base types of the arguments and attempt to bind the non-lifted form of the
// method so that we error report (ie divide by zero etc), and then we store in the resulting
// binop that we have a lifted operator.
EXPR pArgument1 = null;
EXPR pArgument2 = null;
EXPR nonLiftedArg1 = null;
EXPR nonLiftedArg2 = null;
EXPR nonLiftedResult = null;
CType resultType = null;
LiftArgument(arg1, bofs.Type1(), bofs.ConvertFirst(), out pArgument1, out nonLiftedArg1);
LiftArgument(arg2, bofs.Type2(), bofs.ConvertSecond(), out pArgument2, out nonLiftedArg2);
// Now call the non-lifted method to generate errors, and stash the result.
if (!nonLiftedArg1.isNull() && !nonLiftedArg2.isNull())
{
// Only compute the method if theres no nulls. If there are, we'll special case it
// later, since operations with a null operand are null.
nonLiftedResult = bofs.pfn(ek, flags, nonLiftedArg1, nonLiftedArg2);
}
// Check if we have a comparison. If so, set the result type to bool.
if (info.binopKind == BinOpKind.Compare || info.binopKind == BinOpKind.Equal)
{
resultType = GetReqPDT(PredefinedType.PT_BOOL);
}
else
{
if (bofs.fnkind == BinOpFuncKind.EnumBinOp)
{
AggregateType enumType;
resultType = GetEnumBinOpType(ek, nonLiftedArg1.type, nonLiftedArg2.type, out enumType);
}
else
{
resultType = pArgument1.type;
}
resultType = resultType.IsNullableType() ? resultType : GetSymbolLoader().GetTypeManager().GetNullable(resultType);
}
EXPRBINOP exprRes = GetExprFactory().CreateBinop(ek, resultType, pArgument1, pArgument2);
mustCast(nonLiftedResult, resultType, 0);
exprRes.isLifted = true;
exprRes.flags |= flags;
Debug.Assert((exprRes.flags & EXPRFLAG.EXF_LVALUE) == 0);
return exprRes;
}
public virtual ExpressionKind ValueOfKindAsTypeOfKind(ExpressionKind valueKind, ExpressionKind typeKind)
{
if (valueKind == ExpressionKind.TargetCall)
{
return ExpressionKind.Result;
}
if (valueKind == ExpressionKind.Result)
{
return ExpressionKind.Result;
}
if (valueKind == ExpressionKind.Mock)
{
return ExpressionKind.Mock;
}
if (valueKind == ExpressionKind.Target || typeKind == ExpressionKind.Target)
{
return ExpressionKind.Target;
}
return valueKind;
}
public MemberAccessExpressionNode() : super(ExpressionKind.MemberAccess) {}
internal EXPR bindUDUnop(ExpressionKind ek, EXPR arg)
{
Name pName = ekName(ek);
Debug.Assert(pName != null);
CType typeSrc = arg.type;
LAgain:
switch (typeSrc.GetTypeKind())
{
case TypeKind.TK_NullableType:
typeSrc = typeSrc.StripNubs();
goto LAgain;
case TypeKind.TK_TypeParameterType:
typeSrc = typeSrc.AsTypeParameterType().GetEffectiveBaseClass();
goto LAgain;
case TypeKind.TK_AggregateType:
if (!typeSrc.isClassType() && !typeSrc.isStructType() || typeSrc.AsAggregateType().getAggregate().IsSkipUDOps())
return null;
break;
default:
return null;
}
ArgInfos info = new ArgInfos();
info.carg = 1;
FillInArgInfoFromArgList(info, arg);
List<CandidateFunctionMember> methFirstList = new List<CandidateFunctionMember>();
MethodSymbol methCur = null;
AggregateType atsCur = typeSrc.AsAggregateType();
for (; ;)
{
// Find the next operator.
methCur = (methCur == null) ?
GetSymbolLoader().LookupAggMember(pName, atsCur.getAggregate(), symbmask_t.MASK_MethodSymbol).AsMethodSymbol() :
GetSymbolLoader().LookupNextSym(methCur, atsCur.getAggregate(), symbmask_t.MASK_MethodSymbol).AsMethodSymbol();
if (methCur == null)
{
// Find the next type.
// If we've found some applicable methods in a class then we don't need to look any further.
if (!methFirstList.IsEmpty())
break;
atsCur = atsCur.GetBaseClass();
if (atsCur == null)
break;
continue;
}
// Only look at operators with 1 args.
if (!methCur.isOperator || methCur.Params.size != 1)
continue;
Debug.Assert(methCur.typeVars.size == 0);
TypeArray paramsCur = GetTypes().SubstTypeArray(methCur.Params, atsCur);
CType typeParam = paramsCur.Item(0);
NullableType nubParam;
if (canConvert(arg, typeParam))
{
methFirstList.Add(new CandidateFunctionMember(
new MethPropWithInst(methCur, atsCur, BSYMMGR.EmptyTypeArray()),
paramsCur,
0,
false));
}
else if (GetSymbolLoader().FCanLift() && typeParam.IsNonNubValType() &&
GetTypes().SubstType(methCur.RetType, atsCur).IsNonNubValType() &&
canConvert(arg, nubParam = GetTypes().GetNullable(typeParam)))
{
methFirstList.Add(new CandidateFunctionMember(
new MethPropWithInst(methCur, atsCur, BSYMMGR.EmptyTypeArray()),
GetGlobalSymbols().AllocParams(1, new CType[] { nubParam }),
1,
false));
}
}
if (methFirstList.IsEmpty())
return null;
CandidateFunctionMember pmethAmbig1;
CandidateFunctionMember pmethAmbig2;
CandidateFunctionMember pmethBest = FindBestMethod(methFirstList, null, info, out pmethAmbig1, out pmethAmbig2);
if (pmethBest == null)
{
// No winner, so its an ambiguous call...
ErrorContext.Error(ErrorCode.ERR_AmbigCall, pmethAmbig1.mpwi, pmethAmbig2.mpwi);
EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(null, pmethAmbig1.mpwi);
EXPRCALL rval = GetExprFactory().CreateCall(0, null, arg, pMemGroup, null);
rval.SetError();
return rval;
}
if (SemanticChecker.CheckBogus(pmethBest.mpwi.Meth()))
{
ErrorContext.ErrorRef(ErrorCode.ERR_BindToBogus, pmethBest.mpwi);
EXPRMEMGRP pMemGroup = GetExprFactory().CreateMemGroup(null, pmethBest.mpwi);
EXPRCALL rval = GetExprFactory().CreateCall(0, null, arg, pMemGroup, null);
rval.SetError();
return rval;
}
EXPRCALL call;
if (pmethBest.ctypeLift != 0)
{
call = BindLiftedUDUnop(arg, [email protected](0), pmethBest.mpwi);
}
else
{
call = BindUDUnopCall(arg, [email protected](0), pmethBest.mpwi);
}
return GetExprFactory().CreateUserDefinedUnaryOperator(ek, call.type, arg, call, pmethBest.mpwi);
}
: super(ExpressionKind.Value, type) {
this.Value = value;
}
protected MemberAccessExpressionNode(ExpressionKind kind) : super(kind) {}
