public void GenericArrayAsCastExpression() { ParseUtilCSharp.AssertExpression( "o as List<string>[]", new AsExpression { Type = new ComposedType { BaseType = new SimpleType("List") { TypeArguments = { new PrimitiveType("string") } }, ArraySpecifiers = { new ArraySpecifier(1) } }, Expression = new IdentifierExpression("o") }); }
public void MultipleGenerators() { ParseUtilCSharp.AssertExpression( @" from c in customers where c.City == ""London"" from o in c.Orders where o.OrderDate.Year == 2005 select new { c.Name, o.OrderID, o.Total }", new QueryExpression { Clauses = { new QueryFromClause { Identifier = "c", Expression = new IdentifierExpression("customers") }, new QueryWhereClause { Condition = new BinaryOperatorExpression{ Left = new IdentifierExpression("c").Member("City"), Operator = BinaryOperatorType.Equality, Right = new PrimitiveExpression("London") } }, new QueryFromClause { Identifier = "o", Expression = new IdentifierExpression("c").Member("Orders") }, new QueryWhereClause { Condition = new BinaryOperatorExpression{ Left = new IdentifierExpression("o").Member("OrderDate").Member("Year"), Operator = BinaryOperatorType.Equality, Right = new PrimitiveExpression(2005) } }, new QuerySelectClause { Expression = new AnonymousTypeCreateExpression{ Initializers = { new IdentifierExpression("c").Member("Name"), new IdentifierExpression("o").Member("OrderID"), new IdentifierExpression("o").Member("Total") } } } } }); }
public void GenericDefaultValue() { ParseUtilCSharp.AssertExpression( "default(MyNamespace.N1.MyType<string>)", new DefaultValueExpression { Type = new MemberType { Target = new MemberType { Target = new SimpleType("MyNamespace"), MemberName = "N1" }, MemberName = "MyType", TypeArguments = { new PrimitiveType("string") } } }); }
public void ObjectInitializerWithTrailingComma() { ParseUtilCSharp.AssertExpression( "new Point() { X = 0, Y = 1, }", new ObjectCreateExpression { Type = new SimpleType("Point"), Initializer = new ArrayInitializerExpression { Elements = { new NamedExpression("X", new PrimitiveExpression(0)), new NamedExpression("Y", new PrimitiveExpression(1)) } } }); }
public void ArrayWithImplicitSize() { ParseUtilCSharp.AssertExpression( "new int[] { 1 }", new ArrayCreateExpression { Type = new PrimitiveType("int"), AdditionalArraySpecifiers = { new ArraySpecifier(0) }, Initializer = new ArrayInitializerExpression { Elements = { new PrimitiveExpression(1) } } }); }
public void ImplicitlyTypedArrayCreateExpression() { ParseUtilCSharp.AssertExpression( "new[] { 1, 10, 100, 1000 }", new ArrayCreateExpression { Initializer = new ArrayInitializerExpression { Elements = { new PrimitiveExpression(1), new PrimitiveExpression(10), new PrimitiveExpression(100), new PrimitiveExpression(1000) } } }); }
public void ExplicitlyTypedWithRefParameter() { ParseUtilCSharp.AssertExpression( "(ref int i) => i = 1", new LambdaExpression { Parameters = { new ParameterDeclaration { ParameterModifier = ParameterModifier.Ref, Type = new PrimitiveType("int"), Name = "x" } }, Body = new AssignmentExpression(new IdentifierExpression("i"), new PrimitiveExpression(1)) }); }
public void ArglistCall() { ParseUtilCSharp.AssertExpression( "GetArgCount(__arglist(a, b, c))", new IdentifierExpression("GetArgCount").Invoke( new UndocumentedExpression { UndocumentedExpressionType = UndocumentedExpressionType.ArgList, Arguments = { new IdentifierExpression("a"), new IdentifierExpression("b"), new IdentifierExpression("c") } })); }
public void ImplicitlyTypedStatementBodyWithoutParenthesis() { ParseUtilCSharp.AssertExpression( "x => { return x + 1; }", new LambdaExpression { Parameters = { new ParameterDeclaration { Name = "x" } }, Body = new BlockStatement { new ReturnStatement { Expression = new BinaryOperatorExpression( new IdentifierExpression("x"), BinaryOperatorType.Add, new PrimitiveExpression(1)) } } }); }
public void ExplicitlyTypedStatementBody() { ParseUtilCSharp.AssertExpression( "(int x) => { return x + 1; }", new LambdaExpression { Parameters = { new ParameterDeclaration { Type = new PrimitiveType("int"), Name = "x" } }, Body = new BlockStatement { new ReturnStatement { Expression = new BinaryOperatorExpression( new IdentifierExpression("x"), BinaryOperatorType.Add, new PrimitiveExpression(1)) } } }); }
public void CollectionInitializer() { ParseUtilCSharp.AssertExpression( "new List<int> { 0, 1, 2 }", new ObjectCreateExpression { Type = new SimpleType("List", new PrimitiveType("int")), Initializer = new ArrayInitializerExpression { Elements = { new ArrayInitializerExpression(new PrimitiveExpression(0)), new ArrayInitializerExpression(new PrimitiveExpression(1)), new ArrayInitializerExpression(new PrimitiveExpression(2)) } } }); }
public void GenericInvocation2ExpressionTest() { ParseUtilCSharp.AssertExpression( "myMethod<T,bool>()", new InvocationExpression { Target = new IdentifierExpression { Identifier = "myMethod", TypeArguments = { new SimpleType("T"), new PrimitiveType("bool") } } } ); }
public void LambdaExpressionContainingConditionalExpression() { ParseUtilCSharp.AssertExpression( "rr => rr != null ? rr.ResolvedType : null", new LambdaExpression { Parameters = { new ParameterDeclaration { Name = "rr" } }, Body = new ConditionalExpression { Condition = new BinaryOperatorExpression( new IdentifierExpression("rr"), BinaryOperatorType.InEquality, new NullReferenceExpression()), TrueExpression = new IdentifierExpression("rr").Member("ResolvedType"), FalseExpression = new NullReferenceExpression() } }); }
public void SetRefValue() { ParseUtilCSharp.AssertExpression( "__refvalue(tr, object) = o", new AssignmentExpression( new UndocumentedExpression { UndocumentedExpressionType = UndocumentedExpressionType.RefValue, Arguments = { new IdentifierExpression("tr"), new TypeReferenceExpression(new PrimitiveType("object")) } }, new IdentifierExpression("o"))); }
public void AssignmentInArrayInitializer() { ParseUtilCSharp.AssertExpression( "new [] { a = 10 }", new ArrayCreateExpression { AdditionalArraySpecifiers = { new ArraySpecifier(0) }, Initializer = new ArrayInitializerExpression { Elements = { new AssignmentExpression(new IdentifierExpression("a"), new PrimitiveExpression(10)) } } }); }
public void AmbiguousGrammarNotAGenericMethodCall() { ParseUtilCSharp.AssertExpression( "F<A>+y", new BinaryOperatorExpression { Left = new BinaryOperatorExpression { Left = new IdentifierExpression("F"), Operator = BinaryOperatorType.LessThan, Right = new IdentifierExpression("A") }, Operator = BinaryOperatorType.GreaterThan, Right = new UnaryOperatorExpression { Operator = UnaryOperatorType.Plus, Expression = new IdentifierExpression("y") } }); }
public void InvocationWithNamedArgument() { ParseUtilCSharp.AssertExpression( "a(arg: ref v)", new InvocationExpression { Target = new IdentifierExpression("a"), Arguments = { new NamedArgumentExpression { Name = "arg", Expression = new DirectionExpression{ FieldDirection = FieldDirection.Ref, Expression = new IdentifierExpression("v") } } } }); }
public void NestedGenericTypeOfExpressionTest() { ParseUtilCSharp.AssertExpression( "typeof(MyType<string>.InnerClass<int>.InnerInnerClass)", new TypeOfExpression { Type = new MemberType { Target = new MemberType { Target = new SimpleType("MyType") { TypeArguments = { new PrimitiveType("string") } }, MemberName = "InnerClass", TypeArguments = { new PrimitiveType("int") } }, MemberName = "InnerInnerClass" } }); }
public void ExpressionWithType2() { ParseUtilCSharp.AssertExpression( "from int c in customers select c", new QueryExpression { Clauses = { new QueryFromClause { Type = new PrimitiveType("int"), Identifier = "c", Expression = new IdentifierExpression("customers") }, new QuerySelectClause { Expression = new IdentifierExpression("c") } } }); }
public void ExpressionWithType1() { ParseUtilCSharp.AssertExpression( "from Customer c in customers select c", new QueryExpression { Clauses = { new QueryFromClause { Type = new SimpleType("Customer"), Identifier = "c", Expression = new IdentifierExpression("customers") }, new QuerySelectClause { Expression = new IdentifierExpression("c") } } }); }
public void QueryWithGroupBy() { ParseUtilCSharp.AssertExpression( "from a in b group c by d", new QueryExpression { Clauses = { new QueryFromClause { Identifier = "a", Expression = new IdentifierExpression("b") }, new QueryGroupClause { Projection = new IdentifierExpression("c"), Key = new IdentifierExpression("d") } } }); }
public void FullQualifiedDefaultValue() { ParseUtilCSharp.AssertExpression( "default(global::MyNamespace.N1.MyType)", new DefaultValueExpression { Type = new MemberType { Target = new MemberType { Target = new MemberType { Target = new SimpleType("global"), IsDoubleColon = true, MemberName = "MyNamespace" }, MemberName = "N1" }, MemberName = "MyType" } }); }
public void AmbiguousGrammarGenericMethodCall() { ParseUtilCSharp.AssertExpression( "F(G<A,B>(7))", new InvocationExpression { Target = new IdentifierExpression("F"), Arguments = { new InvocationExpression { Target = new IdentifierExpression{ Identifier = "G", TypeArguments = { new SimpleType("A"),new SimpleType("B") } }, Arguments = { new PrimitiveExpression(7) } } } }); }
public void GlobalFullNamespaceGenericFieldReferenceExpressionTest() { var target = new MemberType { Target = new SimpleType("global"), IsDoubleColon = true, MemberName = "Namespace" }.Member("Subnamespace").Member("SomeClass"); target.AddChild(new PrimitiveType("string"), Roles.TypeArgument); ParseUtilCSharp.AssertExpression( "global::Namespace.Subnamespace.SomeClass<string>.myField", new MemberReferenceExpression { Target = target, MemberName = "myField" } ); }
public void DictionaryInitializer() { ParseUtilCSharp.AssertExpression( "new Dictionary<string, int> { { \"a\", 0 }, { \"b\", 1 } }", new ObjectCreateExpression { Type = new SimpleType("Dictionary", new PrimitiveType("string"), new PrimitiveType("int")), Initializer = new ArrayInitializerExpression { Elements = { new ArrayInitializerExpression { Elements = { new PrimitiveExpression("a"), new PrimitiveExpression(0) } }, new ArrayInitializerExpression { Elements = { new PrimitiveExpression("b"), new PrimitiveExpression(1) } } } } }); }
public void AssignmentInCollectionInitializer() { ParseUtilCSharp.AssertExpression( @"new List<int> { { a = 1 } }", new ObjectCreateExpression { Type = new SimpleType("List", new PrimitiveType("int")), Initializer = new ArrayInitializerExpression { Elements = { new ArrayInitializerExpression { Elements = { new AssignmentExpression(new IdentifierExpression("a"), new PrimitiveExpression(1)) } } } } }); }
public void MultipleQueryContinuation() { ParseUtilCSharp.AssertExpression( "from a in b select c into d select e into f select g", new QueryExpression { Clauses = { new QueryContinuationClause { PrecedingQuery = new QueryExpression { Clauses = { new QueryContinuationClause { PrecedingQuery = new QueryExpression{ Clauses = { new QueryFromClause { Identifier = "a", Expression = new IdentifierExpression("b") }, new QuerySelectClause { Expression = new IdentifierExpression("c") } } }, Identifier = "d" }, new QuerySelectClause { Expression = new IdentifierExpression("e") } } }, Identifier = "f" }, new QuerySelectClause { Expression = new IdentifierExpression("g") } } }); }
public void NestedObjectInitializer() { ParseUtilCSharp.AssertExpression( "new Rectangle { P1 = new Point { X = 0, Y = 1 }, P2 = new Point { X = 2, Y = 3 } }", new ObjectCreateExpression { Type = new SimpleType("Rectangle"), Initializer = new ArrayInitializerExpression { Elements = { new NamedExpression( "P1", new ObjectCreateExpression { Type = new SimpleType("Point"), Initializer = new ArrayInitializerExpression { Elements = { new NamedExpression("X", new PrimitiveExpression(0)), new NamedExpression("Y", new PrimitiveExpression(1)) } } }), new NamedExpression( "P2", new ObjectCreateExpression { Type = new SimpleType("Point"), Initializer = new ArrayInitializerExpression { Elements = { new NamedExpression("X", new PrimitiveExpression(2)), new NamedExpression("Y", new PrimitiveExpression(3)) } } }) } } }); }
public void QueryWithJoin() { ParseUtilCSharp.AssertExpression( "from a in b join c in d on e equals f select g", new QueryExpression { Clauses = { new QueryFromClause { Identifier = "a", Expression = new IdentifierExpression("b") }, new QueryJoinClause { JoinIdentifier = "c", InExpression = new IdentifierExpression("d"), OnExpression = new IdentifierExpression("e"), EqualsExpression = new IdentifierExpression("f") }, new QuerySelectClause { Expression = new IdentifierExpression("g") } } }); }
public void ExpressionWithOrderByWithTwoOrderByDecendings() { ParseUtilCSharp.AssertExpression( "from c in customers orderby c.Name descending orderby c.Address descending select c", new QueryExpression { Clauses = { new QueryFromClause { Identifier = "c", Expression = new IdentifierExpression("customers") }, new QueryOrderClause { Orderings = { new QueryOrdering { Expression = new IdentifierExpression("c").Member("Name"), Direction = QueryOrderingDirection.Descending } } }, new QueryOrderClause { Orderings = { new QueryOrdering { Expression = new IdentifierExpression("c").Member("Address"), Direction = QueryOrderingDirection.Descending } } }, new QuerySelectClause { Expression = new IdentifierExpression("c") } } }); }