public IExpressionNode Visit(IfThenElseSyntaxNode node)
{
//expressions
//if (...) {here}
var expressionNodes = new IExpressionNode[node.Ifs.Length];
//conditions
// if ( {here} ) ...
var conditionNodes = new IExpressionNode[node.Ifs.Length];
for (int i = 0; i < expressionNodes.Length; i++)
{
conditionNodes[i] = ReadNode(node.Ifs[i].Condition);
var exprNode = ReadNode(node.Ifs[i].Expression);
expressionNodes[i] = CastExpressionNode.GetConvertedOrOriginOrThrow(exprNode, node.OutputType);
}
var elseNode = CastExpressionNode.GetConvertedOrOriginOrThrow(ReadNode(node.ElseExpr), node.OutputType);
return(new IfElseExpressionNode(
ifExpressionNodes: expressionNodes,
conditionNodes: conditionNodes,
elseNode: elseNode,
interval: node.Interval,
type: node.OutputType));
}
protected override Void handleCast(CastExpressionNode cast, Set <TypeInfo> dependencies, bool nested)
{
var info = cast.getUserData(typeof(ExpressionInfo));
addDependencies(info.Type, dependencies);
handleExpression(cast.Expression, dependencies, true);
return(null);
}
public void GetSupportedMethods()
{
Assert.That(
CastExpressionNode.GetSupportedMethods(),
Is.EquivalentTo(
new[]
{
GetGenericMethodDefinition(() => Queryable.Cast <object> (null)),
GetGenericMethodDefinition(() => Enumerable.Cast <object> (null)),
}));
}
public override void SetUp()
{
base.SetUp();
_cookSource = new MainSourceExpressionNode("s", Expression.Constant(new[] { new Cook() }));
_cookClause = ExpressionHelper.CreateMainFromClause <Cook> ();
ClauseGenerationContext.AddContextInfo(_cookSource, _cookClause);
_castToChefMethod = ReflectionUtility.GetMethod(() => ((IQueryable <Cook[]>)null).Cast <Chef>());
_node = new CastExpressionNode(CreateParseInfo(_cookSource, "s", _castToChefMethod));
}
public IExpressionNode Visit(ArraySyntaxNode node)
{
var elements = new IExpressionNode[node.Expressions.Count];
var expectedElementType = node.OutputType.ArrayTypeSpecification.FunnyType;
for (int i = 0; i < node.Expressions.Count; i++)
{
var elementNode = ReadNode(node.Expressions[i]);
elements[i] = CastExpressionNode.GetConvertedOrOriginOrThrow(elementNode, expectedElementType);
}
return(new ArrayExpressionNode(elements, node.Interval, node.OutputType));
}
protected override CrawlSyntaxNode VisitCastExpression(CastExpressionNode castExpression)
{
var castExp = (CastExpressionNode)base.VisitCastExpression(castExpression);
if (castExp.Target.ResultType.CastableTo(castExp.TypeToConvertTo.ActualType))
{
return(castExp.WithResultType(castExp.TypeToConvertTo.ActualType));
}
else
{
return(castExp.WithResultType(CrawlType.ErrorType));
}
}
public IExpressionNode CreateWithConvertionOrThrow(IList <IExpressionNode> children, Interval interval)
{
var i = 0;
var argNode = children[0];
var toType = ArgTypes[i];
var fromType = argNode.Type;
var castedNode = argNode;
if (fromType != toType)
{
var converter = VarTypeConverter.GetConverterOrThrow(fromType, toType, argNode.Interval);
castedNode = new CastExpressionNode(argNode, toType, converter, argNode.Interval);
}
i++;
return(new FunOfSingleArgExpressionNode(this, castedNode, interval));
}
/// <summary>
/// Creates a <see cref="MethodInfoBasedNodeTypeRegistry"/> and registers all relevant <see cref="IExpressionNode"/> implementations in the <b>Remotion.Linq</b> assembly.
/// </summary>
/// <returns>
/// A <see cref="MethodInfoBasedNodeTypeRegistry"/> with all <see cref="IExpressionNode"/> types in the <b>Remotion.Linq</b> assembly registered.
/// </returns>
public static MethodInfoBasedNodeTypeRegistry CreateFromRelinqAssembly()
{
var registry = new MethodInfoBasedNodeTypeRegistry();
registry.Register(AggregateExpressionNode.GetSupportedMethods(), typeof(AggregateExpressionNode));
registry.Register(AggregateFromSeedExpressionNode.GetSupportedMethods(), typeof(AggregateFromSeedExpressionNode));
registry.Register(AllExpressionNode.GetSupportedMethods(), typeof(AllExpressionNode));
registry.Register(AnyExpressionNode.GetSupportedMethods(), typeof(AnyExpressionNode));
registry.Register(AsQueryableExpressionNode.GetSupportedMethods(), typeof(AsQueryableExpressionNode));
registry.Register(AverageExpressionNode.GetSupportedMethods(), typeof(AverageExpressionNode));
registry.Register(CastExpressionNode.GetSupportedMethods(), typeof(CastExpressionNode));
registry.Register(ConcatExpressionNode.GetSupportedMethods(), typeof(ConcatExpressionNode));
registry.Register(ContainsExpressionNode.GetSupportedMethods(), typeof(ContainsExpressionNode));
registry.Register(CountExpressionNode.GetSupportedMethods(), typeof(CountExpressionNode));
registry.Register(DefaultIfEmptyExpressionNode.GetSupportedMethods(), typeof(DefaultIfEmptyExpressionNode));
registry.Register(DistinctExpressionNode.GetSupportedMethods(), typeof(DistinctExpressionNode));
registry.Register(ExceptExpressionNode.GetSupportedMethods(), typeof(ExceptExpressionNode));
registry.Register(FirstExpressionNode.GetSupportedMethods(), typeof(FirstExpressionNode));
registry.Register(GroupByExpressionNode.GetSupportedMethods(), typeof(GroupByExpressionNode));
registry.Register(GroupByWithResultSelectorExpressionNode.GetSupportedMethods(), typeof(GroupByWithResultSelectorExpressionNode));
registry.Register(GroupJoinExpressionNode.GetSupportedMethods(), typeof(GroupJoinExpressionNode));
registry.Register(IntersectExpressionNode.GetSupportedMethods(), typeof(IntersectExpressionNode));
registry.Register(JoinExpressionNode.GetSupportedMethods(), typeof(JoinExpressionNode));
registry.Register(LastExpressionNode.GetSupportedMethods(), typeof(LastExpressionNode));
registry.Register(LongCountExpressionNode.GetSupportedMethods(), typeof(LongCountExpressionNode));
registry.Register(MaxExpressionNode.GetSupportedMethods(), typeof(MaxExpressionNode));
registry.Register(MinExpressionNode.GetSupportedMethods(), typeof(MinExpressionNode));
registry.Register(OfTypeExpressionNode.GetSupportedMethods(), typeof(OfTypeExpressionNode));
registry.Register(OrderByDescendingExpressionNode.GetSupportedMethods(), typeof(OrderByDescendingExpressionNode));
registry.Register(OrderByExpressionNode.GetSupportedMethods(), typeof(OrderByExpressionNode));
registry.Register(ReverseExpressionNode.GetSupportedMethods(), typeof(ReverseExpressionNode));
registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
registry.Register(SelectManyExpressionNode.GetSupportedMethods(), typeof(SelectManyExpressionNode));
registry.Register(SingleExpressionNode.GetSupportedMethods(), typeof(SingleExpressionNode));
registry.Register(SkipExpressionNode.GetSupportedMethods(), typeof(SkipExpressionNode));
registry.Register(SumExpressionNode.GetSupportedMethods(), typeof(SumExpressionNode));
registry.Register(TakeExpressionNode.GetSupportedMethods(), typeof(TakeExpressionNode));
registry.Register(ThenByDescendingExpressionNode.GetSupportedMethods(), typeof(ThenByDescendingExpressionNode));
registry.Register(ThenByExpressionNode.GetSupportedMethods(), typeof(ThenByExpressionNode));
registry.Register(UnionExpressionNode.GetSupportedMethods(), typeof(UnionExpressionNode));
registry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode));
return(registry);
}
public IExpressionNode CreateWithConvertionOrThrow(IList <IExpressionNode> children, Interval interval)
{
var castedChildren = new IExpressionNode[children.Count];
var i = 0;
foreach (var argNode in children)
{
var toType = ArgTypes[i];
var fromType = argNode.Type;
var castedNode = argNode;
if (fromType != toType)
{
var converter = VarTypeConverter.GetConverterOrThrow(fromType, toType, argNode.Interval);
castedNode = new CastExpressionNode(argNode, toType, converter, argNode.Interval);
}
castedChildren[i] = castedNode;
i++;
}
return(new FunOfTwoArgsExpressionNode(this, castedChildren[0], castedChildren[1], interval));
}
protected override AssignmentState handleCast(CastExpressionNode cast, HashSet <StatementNode> visited, bool nested)
{
return(handleExpression(cast.Expression, visited, true));
}
public override PapyrusType VisitCastExpression(CastExpressionNode node)
{
return(node.TypeIdentifier.GetReferencedType());
}
