public override INode VisitNullLiteral(NullLiteral nullLiteral) { return(new NullLiteral(nullLiteral.Context) { Type = nullLiteral.Type }); }
public override Ust VisitConditionalAccessExpression(ConditionalAccessExpressionSyntax node) { Ust ustNode = base.Visit(node.Expression); Expression expression = ustNode as Expression; if (expression == null) { expression = new MultichildExpression(((ArgsUst)ustNode).Collection, ustNode.TextSpan); } Expression whenNotNullExpression; if (node.WhenNotNull is ElementBindingExpressionSyntax) { var args = (ArgsUst)VisitElementBindingExpression((ElementBindingExpressionSyntax)node.WhenNotNull); whenNotNullExpression = new IndexerExpression(expression, args, args.TextSpan); } else { whenNotNullExpression = (Expression)base.Visit(node.WhenNotNull); } var nullExpr = new NullLiteral(default(TextSpan)); var binayOpLiteral = new BinaryOperatorLiteral(BinaryOperator.Equal, default(TextSpan)); var condition = new BinaryOperatorExpression(expression, binayOpLiteral, nullExpr, default(TextSpan)); var result = new ConditionalExpression(condition, nullExpr, whenNotNullExpression, node.GetTextSpan()); return(result); }
public void TestNullLiteral() { var actual = new NullLiteral().Print(); var expected = "NULL"; actual.Should().Be(expected); }
public override IQueryElement VisitLiteral([NotNull] QueryGrammarParser.LiteralContext context) { if (context.NUMBER() != null) { IntegerLiteral literal = new IntegerLiteral(); literal.Value = context.NUMBER().GetText(); return(literal); } else if (context.STRING_VALUE() != null) { StringLiteral literal = new StringLiteral(); literal.Value = context.STRING_VALUE().GetText().Replace("'", "\""); return(literal); } else if (context.BOOL_VALUE() != null) { BoolLiteral literal = new BoolLiteral(); literal.Value = context.BOOL_VALUE().GetText(); return(literal); } else if (context.NULL_VALUE() != null) { NullLiteral literal = new NullLiteral(); return(literal); } throw new SyntaxException("Unsupported literal."); }
public void TestNullLiteralAccept() { Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>(); NullLiteral nullLiteral = new NullLiteral(); nullLiteral.Accept(mock.Object); mock.Verify(x => x.VisitNullLiteral(nullLiteral)); }
public override void Visit(NullLiteral node) { PushLocation(node); _ilGen.LoadRuntimeInstance(); _ilGen.Ldfld(Types.Runtime.DefaultDNull); _result.ValueType = mdr.ValueTypes.Null; PopLocation(); }
public void TestCloneNullLiteral() { NullLiteral nullLiteral = new NullLiteral(); var clone = nullLiteral.Clone(); Assert.AreEqual(nullLiteral, clone); Assert.IsFalse(ReferenceEquals(nullLiteral, clone)); }
private SpelNode EatExpression() { var expr = EatLogicalOrExpression(); var t = PeekToken(); if (t != null) { if (t.Kind == TokenKind.ASSIGN) { // a=b if (expr == null) { expr = new NullLiteral(t.StartPos - 1, t.EndPos - 1); } NextToken(); var assignedValue = EatLogicalOrExpression(); return(new Assign(t.StartPos, t.EndPos, expr, assignedValue)); } if (t.Kind == TokenKind.ELVIS) { // a?:b (a if it isn't null, otherwise b) if (expr == null) { expr = new NullLiteral(t.StartPos - 1, t.EndPos - 2); } NextToken(); // elvis has left the building var valueIfNull = EatExpression(); if (valueIfNull == null) { valueIfNull = new NullLiteral(t.StartPos + 1, t.EndPos + 1); } return(new Elvis(t.StartPos, t.EndPos, expr, valueIfNull)); } if (t.Kind == TokenKind.QMARK) { // a?b:c if (expr == null) { expr = new NullLiteral(t.StartPos - 1, t.EndPos - 1); } NextToken(); var ifTrueExprValue = EatExpression(); EatToken(TokenKind.COLON); var ifFalseExprValue = EatExpression(); return(new Ternary(t.StartPos, t.EndPos, expr, ifTrueExprValue, ifFalseExprValue)); } } return(expr); }
public void TestNullLiteralEquals() { NullLiteral first = new NullLiteral(); NullLiteral second = new NullLiteral(); Assert.IsTrue(Equals(first, second)); //Hash code Assert.AreEqual(first.GetHashCode(), second.GetHashCode()); }
protected override void VisitNullLiteral(NullLiteral item) { if (IsVisitingFilterItem) { IdFilterValue = null; } else { throw new NotSupportedException(); } }
public void TestVisitNullLiteral() { NullLiteral nullLiteral = new NullLiteral(); KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor(); koraliumSqlVisitor.Visit(nullLiteral); //Nothing to verify yet, only that no exceptions are thrown Assert.Pass(); }
protected override void VisitNullLiteral(NullLiteral item) { if (CurrentUpdateStatementPart == UpdateStatementPart.WhereClause) { IdFilterValue = null; } else { var attName = GetColumnLogicalAttributeName(this.CurrentSetterColumn); EntityBuilder.WithAttribute(attName).SetValueWithTypeCoersion(null); } }
public void AllowNullEqualityComparison(string op) { var nullVal = new NullLiteral (); var numberVal = new NumberLiteral (42); var left = new BinaryOperation (op, nullVal, numberVal); var right = new BinaryOperation (op, numberVal, nullVal); var leftType = left.Walk (new TypeChecker ()); var rightType = right.Walk (new TypeChecker ()); Assert.AreEqual (SpecType.Boolean, leftType.Type); Assert.AreEqual (SpecType.Boolean, rightType.Type); }
public override UstNode VisitBinaryExpression(BinaryExpressionSyntax node) { if (node.OperatorToken.ValueText == "is") // x is y -> (y)x != null { var type = ConvertType(base.Visit(node.Right)); var expression = (Expression)base.Visit(node.Left); var left = new CastExpression(type, expression, node.GetTextSpan(), FileNode); var operatorSpan = node.OperatorToken.GetTextSpan(); var literal = new BinaryOperatorLiteral(BinaryOperator.NotEqual, operatorSpan, FileNode); var right = new NullLiteral(operatorSpan, FileNode); var result = new BinaryOperatorExpression(left, literal, right, node.GetTextSpan(), FileNode); return(result); } if (node.OperatorToken.ValueText == "as") { var type = ConvertType(base.Visit(node.Right)); var expression = (Expression)base.Visit(node.Left); var result = new CastExpression(type, expression, node.GetTextSpan(), FileNode); return(result); } if (node.OperatorToken.ValueText == "??") { var trueExpression = (Expression)base.Visit(node.Left); var operatorSpan = node.OperatorToken.GetTextSpan(); var condition = new BinaryOperatorExpression( trueExpression, new BinaryOperatorLiteral(BinaryOperator.NotEqual, operatorSpan, FileNode), new NullLiteral(operatorSpan, FileNode), operatorSpan, FileNode); var falseExpression = (Expression)base.Visit(node.Right); var result = new ConditionalExpression(condition, trueExpression, falseExpression, node.GetTextSpan(), FileNode); return(result); } else { var result = CreateBinaryOperatorExpression(node); return(result); } }
public static Literal /*!*/ Create(Text.Span position, object value, AccessType access) { Literal result; if (value == null) { result = new NullLiteral(position); } else if (value.GetType() == typeof(int)) { result = new IntLiteral(position, (int)value); } else if (value.GetType() == typeof(string)) { result = new StringLiteral(position, (string)value); } else if (value.GetType() == typeof(bool)) { result = new BoolLiteral(position, (bool)value); } else if (value.GetType() == typeof(double)) { result = new DoubleLiteral(position, (double)value); } else if (value.GetType() == typeof(long)) { result = new LongIntLiteral(position, (long)value); } else if (value.GetType() == typeof(PhpBytes)) { result = new BinaryStringLiteral(position, ((PhpBytes)value).ReadonlyData); } else { throw new ArgumentException("value"); } // Debug.Assert(result != null); result.NodeCompiler <IExpressionCompiler>().Access = access; // return(result); }
public UstNode VisitLiteral(DslParser.LiteralContext context) { Token result; var textSpan = context.GetTextSpan(); if (context.Id() != null) { result = ProcessId(context.Id()); } else if (context.String() != null) { result = new StringLiteral(RemoveQuotes(context.GetText()), textSpan, null); } else if (context.Oct() != null) { result = new IntLiteral( System.Convert.ToInt64(context.Oct().GetText(), 8), textSpan, null); } else if (context.Int() != null) { result = new IntLiteral(long.Parse(context.Int().GetText()), textSpan, null); } else if (context.Hex() != null) { result = new IntLiteral( System.Convert.ToInt64(context.Hex().GetText(), 16), textSpan, null); } else if (context.Bool() != null) { result = new BooleanLiteral(bool.Parse(context.Bool().GetText()), textSpan, null); } else if (context.Null() != null) { result = new NullLiteral(textSpan, null); } else { throw new NotImplementedException(); } return(result); }
public override Expression DoResolve(ResolveContext ec) { // // It's null when lifting non-nullable type // if (unwrap == null) { // S -> T? is wrap only if (TypeManager.IsNullableType(type)) { return(Wrap.Create(expr, type)); } // S -> T can be simplified return(expr); } // Wrap target for T? if (TypeManager.IsNullableType(type)) { expr = Wrap.Create(expr, type); if (expr == null) { return(null); } null_value = LiftedNull.Create(type, loc); } else { null_value = new NullLiteral(type, loc); } eclass = ExprClass.Value; return(this); }
public override object?Visit(NullLiteral node) { AddNodeInfo(); return(null); }
// Literal := 'true' | 'false' | 'null' | 'self' | SequenceLiteral | StringLiteral private Expression DoParseLiteral(List<string> locals) { Expression result = null; int line = m_scanner.Token.Line; if (m_scanner.Token.IsKeyword("true")) { result = new BooleanLiteral(line, true); m_scanner.Advance(); } else if (m_scanner.Token.IsKeyword("false")) { result = new BooleanLiteral(line, false); m_scanner.Advance(); } else if (m_scanner.Token.IsKeyword("null")) { result = new NullLiteral(line); m_scanner.Advance(); } else if (m_scanner.Token.IsKeyword("self")) { result = new SelfLiteral(line); m_scanner.Advance(); } else if (m_scanner.Token.IsPunct("[")) { m_scanner.Advance(); result = DoParseSequenceLiteral(line, locals); } else if (m_scanner.Token.Kind == TokenKind.String) { result = DoParseStringLiteral(locals); } return result; }
public virtual void ExitNullLiteral(NullLiteral nullLiteral) { }
protected virtual string GetLiteralSql (NullLiteral literal) { return "NULL"; }
public void VisitNullLiteral(NullLiteral nullLiteral) { ReturnValue = nullLiteral; }
public virtual Expression visit(NullLiteral literal) { return(literal); }
public void ErrorOnNullInequalityComparison(string op) { var nullVal = new NullLiteral (); var numberVal = new NumberLiteral (42); var left = new BinaryOperation (op, nullVal, numberVal); var right = new BinaryOperation (op, numberVal, nullVal); var leftEx = Assert.Throws<TypeCheckException> (() => left.Walk (new TypeChecker ())); var rightEx = Assert.Throws<TypeCheckException> (() => right.Walk (new TypeChecker ())); Assert.That (INVALID_RE.IsMatch (leftEx.Message)); Assert.That (INVALID_RE.IsMatch (rightEx.Message)); }
void IVisitor.Visit(NullLiteral literal) { this.ParentExists(literal); }
public virtual T Visit(NullLiteral expr) => Visit(expr as LiteralExpression);
public void CheckNullLiterals() { var nullNode = new NullLiteral (); var type = nullNode.Walk (new TypeChecker()); Assert.AreEqual (SpecType.Any, type.Type); }
override public void VisitNullLiteral(NullLiteral x) { _serializer.Serialize(typeof(NullLiteral).Name, SerializeSpan(x.Span), new NodeObj("Value", "null")); }
public void SerializeNull() { var nullNode = new NullLiteral (); var nullSql = nullNode.Walk (new Sqlizer (foobarTable())); Assert.AreEqual ("NULL", nullSql); }
public override void Visit(NullLiteral node) { this.action(node); }
public void DisjunctionErrorsOnNull() { var nullVal = new NullLiteral (); var boolVal = new BooleanLiteral (true); var left = new LogicalDisjunction (nullVal, boolVal); var right = new LogicalDisjunction (boolVal, nullVal); var leftEx = Assert.Throws<TypeCheckException>(() => left.Walk (new TypeChecker ())); var rightEx = Assert.Throws<TypeCheckException>(() => right.Walk (new TypeChecker ())); Assert.That (INCOMPATIBLE_RE.IsMatch (leftEx.Message)); Assert.That (INCOMPATIBLE_RE.IsMatch (rightEx.Message)); }
public override void Visit(NullLiteral node) { Visit((Literal)node); }
public override void VisitNullLiteral(NullLiteral x) { visitConstantNularyElement(x, (e) => e.NullLiteral(x) ); }
/// <inheritdoc /> public override void VisitNullLiteral(NullLiteral x) { RValueResult(x); }
public void CheckOperatorDoesNothing() { var str = new StringLiteral ("baz"); var nullNode = new NullLiteral (); var operation = new BinaryOperation ("=", str, nullNode); var result = operation.Walk (new RefChecker (), new [] { "Foobar" }); Assert.AreEqual (1, result.Length); Assert.Contains ("Foobar", result); }
public virtual void EnterNullLiteral(NullLiteral nullLiteral) { }
public void CheckNullDoesNothing() { var nullNode = new NullLiteral (); var result = nullNode.Walk (new RefChecker (), new [] { "Foobar" }); Assert.AreEqual (1, result.Length); Assert.Contains ("Foobar", result); }
private Expression ParsePrimaryExpression(TokenSet followers) //^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile; { ISourceLocation sctx = this.scanner.SourceLocationOfLastScannedToken; Expression expression = new DummyExpression(sctx); switch (this.currentToken) { case Token.ArgList: this.GetNextToken(); expression = new RuntimeArgumentHandleExpression(sctx); break; case Token.Delegate: expression = this.ParseAnonymousMethod(followers); break; case Token.New: expression = this.ParseNew(followers|Token.Dot|Token.LeftBracket|Token.Arrow); break; case Token.Identifier: expression = this.ParseSimpleName(followers|Token.Dot|Token.DoubleColon|Token.Lambda|Token.LeftParenthesis); if (this.currentToken == Token.DoubleColon) { if (((SimpleName)expression).Name == this.nameTable.global) expression = new RootNamespaceExpression(expression.SourceLocation); expression = this.ParseQualifiedName(expression, followers|Token.Dot|Token.LessThan|Token.LeftParenthesis|Token.AddOne|Token.SubtractOne); } else if (this.currentToken == Token.Lambda) { expression = this.ParseLambda((SimpleName)expression, followers); } break; case Token.Null: expression = new NullLiteral(sctx); this.GetNextToken(); break; case Token.True: expression = new CompileTimeConstant(true, false, sctx); this.GetNextToken(); break; case Token.False: expression = new CompileTimeConstant(false, false, sctx); this.GetNextToken(); break; case Token.CharLiteral: expression = new CompileTimeConstant(this.scanner.charLiteralValue, false, sctx); this.GetNextToken(); break; case Token.HexLiteral: expression = this.ParseHexLiteral(); break; case Token.IntegerLiteral: expression = this.ParseIntegerLiteral(); break; case Token.RealLiteral: expression = this.ParseRealLiteral(); break; case Token.StringLiteral: expression = new CompileTimeConstant(this.scanner.GetString(), false, sctx); this.GetNextToken(); break; case Token.This: expression = new ThisReference(sctx); this.GetNextToken(); break; case Token.Base: expression = new BaseClassReference(sctx); this.GetNextToken(); break; case Token.Typeof: case Token.Sizeof: case Token.Default: expression = this.ParseTypeofSizeofOrDefault(followers); break; case Token.Stackalloc: return this.ParseStackalloc(followers); case Token.Checked: case Token.MakeRef: case Token.RefType: case Token.Unchecked: expression = this.ParseCheckedOrMakeRefOrRefTypeOrUnchecked(followers); break; case Token.RefValue: expression = this.ParseGetValueOfTypedReference(followers); break; case Token.Bool: case Token.Decimal: case Token.Sbyte: case Token.Byte: case Token.Short: case Token.Ushort: case Token.Int: case Token.Uint: case Token.Long: case Token.Ulong: case Token.Char: case Token.Float: case Token.Double: case Token.Object: case Token.String: expression = this.RootQualifiedNameFor(this.currentToken, sctx); this.GetNextToken(); break; case Token.LeftParenthesis: expression = this.ParseCastExpression(followers|Token.Dot|Token.LeftBracket|Token.Arrow); break; default: if (Parser.IdentifierOrNonReservedKeyword[this.currentToken]) goto case Token.Identifier; if (Parser.InfixOperators[this.currentToken]) { this.HandleError(Error.InvalidExprTerm, this.scanner.GetTokenSource()); //^ assume this.currentToken != Token.EndOfFile; //should not be a member of InfixOperators this.GetNextToken(); } else this.SkipTo(followers|Parser.PrimaryStart, Error.InvalidExprTerm, this.scanner.GetTokenSource()); if (Parser.PrimaryStart[this.currentToken]) return this.ParsePrimaryExpression(followers); goto done; } expression = this.ParseIndexerCallOrSelector(expression, followers|Token.AddOne|Token.SubtractOne); for (; ; ) { switch (this.currentToken) { case Token.AddOne: SourceLocationBuilder slb = new SourceLocationBuilder(expression.SourceLocation); slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken); this.GetNextToken(); expression = new PostfixIncrement(new TargetExpression(expression), slb); break; case Token.SubtractOne: slb = new SourceLocationBuilder(expression.SourceLocation); slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken); this.GetNextToken(); expression = new PostfixDecrement(new TargetExpression(expression), slb); break; case Token.Arrow: case Token.Dot: case Token.LeftBracket: expression = this.ParseIndexerCallOrSelector(expression, followers|Token.AddOne|Token.SubtractOne); break; default: goto done; } } done: this.SkipTo(followers); return expression; }
virtual public void VisitNullLiteral(NullLiteral x) { // nothing }
public override void ExplicitVisit(NullLiteral fragment) { _fragments.Add(fragment); }
public void Visit(NullLiteral literal, CommonTree tree) { Parent(tree).Children.Add(literal); SetLine(literal, tree); }
/// <summary> /// Create null representation of given literal /// </summary> /// <param name="x">Literal value</param> /// <returns>Created literal value representation</returns> public virtual MemoryEntry NullLiteral(NullLiteral x) { return(new MemoryEntry(OutSet.UndefinedValue)); }
public override void VisitNullLiteral(NullLiteral x) { _composer.ConsumeLiteral(x); }
public override Expression DoResolve (ResolveContext ec) { // // It's null when lifting non-nullable type // if (unwrap == null) { // S -> T? is wrap only if (TypeManager.IsNullableType (type)) return Wrap.Create (expr, type); // S -> T can be simplified return expr; } // Wrap target for T? if (TypeManager.IsNullableType (type)) { expr = Wrap.Create (expr, type); if (expr == null) return null; null_value = LiftedNull.Create (type, loc); } else { null_value = new NullLiteral (type, loc); } eclass = ExprClass.Value; return this; }