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;
}
