nub31/nub-lang-archive
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Improved nodes

Browse Source
This commit is contained in:
nub31
2025-10-23 19:17:51 +02:00
parent 08ac59d933
commit ae08e69b8a
5 changed files with 395 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

360
compiler/NubLang.LSP/AstExtensions.cs
View File

@@ -68,368 +68,10 @@ public static class AstExtensions
public static Node? DeepestNodeAtPosition(this CompilationUnit compilationUnit, int line, int character)
{
return compilationUnit.Functions
.SelectMany(x => x.EnumerateDescendantsAndSelf())
.SelectMany(x => x.DescendantsAndSelf())
.Where(n => n.ContainsPosition(line, character))
.OrderBy(n => n.Tokens.First().Span.Start.Line)
.ThenBy(n => n.Tokens.First().Span.Start.Column)
.LastOrDefault();
}
public static Node? DeepestNodeAtPosition(this Node node, int line, int character)
{
return node.EnumerateDescendantsAndSelf()
.Where(n => n.ContainsPosition(line, character))
.OrderBy(n => n.Tokens.First().Span.Start.Line)
.ThenBy(n => n.Tokens.First().Span.Start.Column)
.LastOrDefault();
}
public static IEnumerable<Node> EnumerateDescendantsAndSelf(this Node node)
{
yield return node;
switch (node)
{
case FuncNode func:
{
foreach (var n in func.Prototype.EnumerateDescendantsAndSelf())
{
yield return n;
}
if (func.Body != null)
{
foreach (var n in func.Body.EnumerateDescendantsAndSelf())
{
yield return n;
}
}
break;
}
case FuncPrototypeNode proto:
{
foreach (var n in proto.Parameters.SelectMany(param => param.EnumerateDescendantsAndSelf()))
{
yield return n;
}
break;
}
case BlockNode block:
{
foreach (var n in block.Statements.SelectMany(stmt => stmt.EnumerateDescendantsAndSelf()))
{
yield return n;
}
break;
}
case StatementFuncCallNode stmtCall:
{
foreach (var n in stmtCall.FuncCall.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ReturnNode { Value: not null } ret:
{
foreach (var n in ret.Value.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case AssignmentNode assign:
{
foreach (var n in assign.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in assign.Value.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case IfNode ifNode:
{
foreach (var n in ifNode.Condition.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in ifNode.Body.EnumerateDescendantsAndSelf())
{
yield return n;
}
if (ifNode.Else.HasValue)
{
if (ifNode.Else.Value.IsCase1(out var elseIfNode))
{
foreach (var n in elseIfNode.EnumerateDescendantsAndSelf())
{
yield return n;
}
}
else if (ifNode.Else.Value.IsCase2(out var elseNode))
{
foreach (var n in elseNode.EnumerateDescendantsAndSelf())
{
yield return n;
}
}
}
break;
}
case VariableDeclarationNode decl:
{
if (decl.Assignment != null)
{
foreach (var n in decl.Assignment.EnumerateDescendantsAndSelf())
{
yield return n;
}
}
break;
}
case WhileNode whileNode:
{
foreach (var n in whileNode.Condition.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in whileNode.Body.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ForSliceNode forSlice:
{
foreach (var n in forSlice.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in forSlice.Body.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ForConstArrayNode forConst:
{
foreach (var n in forConst.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in forConst.Body.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case DeferNode defer:
{
foreach (var n in defer.Statement.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case BinaryExpressionNode bin:
{
foreach (var n in bin.Left.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in bin.Right.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case UnaryExpressionNode unary:
{
foreach (var n in unary.Operand.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case FuncCallNode call:
{
foreach (var n in call.Expression.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in call.Parameters.SelectMany(param => param.EnumerateDescendantsAndSelf()))
{
yield return n;
}
break;
}
case ArrayInitializerNode arrInit:
{
foreach (var n in arrInit.Values.SelectMany(val => val.EnumerateDescendantsAndSelf()))
{
yield return n;
}
break;
}
case ConstArrayInitializerNode constArrInit:
{
foreach (var n in constArrInit.Values.SelectMany(val => val.EnumerateDescendantsAndSelf()))
{
yield return n;
}
break;
}
case ArrayIndexAccessNode arrIndex:
{
foreach (var n in arrIndex.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in arrIndex.Index.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ConstArrayIndexAccessNode constArrIndex:
{
foreach (var n in constArrIndex.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in constArrIndex.Index.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case SliceIndexAccessNode sliceIndex:
{
foreach (var n in sliceIndex.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
foreach (var n in sliceIndex.Index.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case AddressOfNode addr:
{
foreach (var n in addr.LValue.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case StructFieldAccessNode field:
{
foreach (var n in field.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case StructInitializerNode structInit:
{
foreach (var n in structInit.Initializers.SelectMany(kv => kv.Value.EnumerateDescendantsAndSelf()))
{
yield return n;
}
break;
}
case DereferenceNode deref:
{
foreach (var n in deref.Target.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ConvertIntNode convInt:
{
foreach (var n in convInt.Value.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ConvertFloatNode convFloat:
{
foreach (var n in convFloat.Value.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ConvertCStringToStringNode convStr:
{
foreach (var n in convStr.Value.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case FloatToIntBuiltinNode ftoi:
{
foreach (var n in ftoi.Value.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
case ConstArrayToSliceNode constSlice:
{
foreach (var n in constSlice.Array.EnumerateDescendantsAndSelf())
{
yield return n;
}
break;
}
}
}
}

5
compiler/NubLang.LSP/CompletionHandler.cs
View File

@@ -150,9 +150,8 @@ internal class CompletionHandler(WorkspaceManager workspaceManager) : Completion
});
}
var variables = function
.Body!
.EnumerateDescendantsAndSelf()
var variables = function.Body!
.Descendants()
.OfType<VariableDeclarationNode>();
foreach (var variable in variables)

2
compiler/NubLang.LSP/DefinitionHandler.cs
View File

@@ -44,7 +44,7 @@ internal class DefinitionHandler(WorkspaceManager workspaceManager) : Definition
}
var variable = function?.Body?
.EnumerateDescendantsAndSelf()
.Descendants()
.OfType<VariableDeclarationNode>()
.FirstOrDefault(x => x.Name == variableIdentifierNode.Name);

441
compiler/NubLang/Ast/Node.cs
View File

@@ -2,17 +2,62 @@ using NubLang.Syntax;
namespace NubLang.Ast;
public abstract record Node(List<Token> Tokens);
public abstract record Node(List<Token> Tokens)
{
public abstract IEnumerable<Node> Children();
public IEnumerable<Node> Descendants()
{
foreach (var child in Children())
{
foreach (var descendant in child.DescendantsAndSelf())
{
yield return descendant;
}
}
}
public IEnumerable<Node> DescendantsAndSelf()
{
yield return this;
foreach (var descendant in Descendants())
{
yield return descendant;
}
}
}
#region Definitions
public abstract record DefinitionNode(List<Token> Tokens, string Module, string Name) : Node(Tokens);
public record FuncParameterNode(List<Token> Tokens, string Name, NubType Type) : Node(Tokens);
public record FuncParameterNode(List<Token> Tokens, string Name, NubType Type) : Node(Tokens)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record FuncPrototypeNode(List<Token> Tokens, string Module, string Name, string? ExternSymbol, List<FuncParameterNode> Parameters, NubType ReturnType) : Node(Tokens);
public record FuncPrototypeNode(List<Token> Tokens, string Module, string Name, string? ExternSymbol, List<FuncParameterNode> Parameters, NubType ReturnType) : Node(Tokens)
{
public override IEnumerable<Node> Children()
{
return Parameters;
}
}
public record FuncNode(List<Token> Tokens, FuncPrototypeNode Prototype, BlockNode? Body) : DefinitionNode(Tokens, Prototype.Module, Prototype.Name);
public record FuncNode(List<Token> Tokens, FuncPrototypeNode Prototype, BlockNode? Body) : DefinitionNode(Tokens, Prototype.Module, Prototype.Name)
{
public override IEnumerable<Node> Children()
{
yield return Prototype;
if (Body != null)
{
yield return Body;
}
}
}
#endregion
@@ -22,29 +67,110 @@ public abstract record StatementNode(List<Token> Tokens) : Node(Tokens);
public abstract record TerminalStatementNode(List<Token> Tokens) : StatementNode(Tokens);
public record BlockNode(List<Token> Tokens, List<StatementNode> Statements) : StatementNode(Tokens);
public record BlockNode(List<Token> Tokens, List<StatementNode> Statements) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
return Statements;
}
}
public record StatementFuncCallNode(List<Token> Tokens, FuncCallNode FuncCall) : StatementNode(Tokens);
public record StatementFuncCallNode(List<Token> Tokens, FuncCallNode FuncCall) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
yield return FuncCall;
}
}
public record ReturnNode(List<Token> Tokens, ExpressionNode? Value) : TerminalStatementNode(Tokens);
public record ReturnNode(List<Token> Tokens, ExpressionNode? Value) : TerminalStatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
if (Value != null) yield return Value;
}
}
public record AssignmentNode(List<Token> Tokens, LValueExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens);
public record AssignmentNode(List<Token> Tokens, LValueExpressionNode Target, ExpressionNode Value) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
yield return Target;
yield return Value;
}
}
public record IfNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body, Variant<IfNode, BlockNode>? Else) : StatementNode(Tokens);
public record IfNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body, Variant<IfNode, BlockNode>? Else) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
yield return Condition;
yield return Body;
if (Else.HasValue)
{
yield return Else.Value.Match<Node>(x => x, x => x);
}
}
}
public record VariableDeclarationNode(List<Token> Tokens, string Name, ExpressionNode? Assignment, NubType Type) : StatementNode(Tokens);
public record VariableDeclarationNode(List<Token> Tokens, string Name, ExpressionNode? Assignment, NubType Type) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
if (Assignment != null) yield return Assignment;
}
}
public record ContinueNode(List<Token> Tokens) : TerminalStatementNode(Tokens);
public record ContinueNode(List<Token> Tokens) : TerminalStatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record BreakNode(List<Token> Tokens) : TerminalStatementNode(Tokens);
public record BreakNode(List<Token> Tokens) : TerminalStatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record WhileNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);
public record WhileNode(List<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
yield return Condition;
yield return Body;
}
}
public record ForSliceNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens);
public record ForSliceNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
yield return Target;
yield return Body;
}
}
public record ForConstArrayNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens);
public record ForConstArrayNode(List<Token> Tokens, string ElementName, string? IndexName, ExpressionNode Target, BlockNode Body) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
yield return Target;
yield return Body;
}
}
public record DeferNode(List<Token> Tokens, StatementNode Statement) : StatementNode(Tokens);
public record DeferNode(List<Token> Tokens, StatementNode Statement) : StatementNode(Tokens)
{
public override IEnumerable<Node> Children()
{
yield return Statement;
}
}
#endregion
@@ -86,72 +212,287 @@ public abstract record RValueExpressionNode(List<Token> Tokens, NubType Type) :
public abstract record IntermediateExpression(List<Token> Tokens) : ExpressionNode(Tokens, new NubVoidType());
public record StringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubStringType());
public record StringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubStringType())
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record CStringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubCStringType());
public record CStringLiteralNode(List<Token> Tokens, string Value) : RValueExpressionNode(Tokens, new NubCStringType())
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record I8LiteralNode(List<Token> Tokens, sbyte Value) : RValueExpressionNode(Tokens, new NubIntType(true, 8));
public record I8LiteralNode(List<Token> Tokens, sbyte Value) : RValueExpressionNode(Tokens, new NubIntType(true, 8))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record I16LiteralNode(List<Token> Tokens, short Value) : RValueExpressionNode(Tokens, new NubIntType(true, 16));
public record I16LiteralNode(List<Token> Tokens, short Value) : RValueExpressionNode(Tokens, new NubIntType(true, 16))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record I32LiteralNode(List<Token> Tokens, int Value) : RValueExpressionNode(Tokens, new NubIntType(true, 32));
public record I32LiteralNode(List<Token> Tokens, int Value) : RValueExpressionNode(Tokens, new NubIntType(true, 32))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record I64LiteralNode(List<Token> Tokens, long Value) : RValueExpressionNode(Tokens, new NubIntType(true, 64));
public record I64LiteralNode(List<Token> Tokens, long Value) : RValueExpressionNode(Tokens, new NubIntType(true, 64))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record U8LiteralNode(List<Token> Tokens, byte Value) : RValueExpressionNode(Tokens, new NubIntType(false, 8));
public record U8LiteralNode(List<Token> Tokens, byte Value) : RValueExpressionNode(Tokens, new NubIntType(false, 8))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record U16LiteralNode(List<Token> Tokens, ushort Value) : RValueExpressionNode(Tokens, new NubIntType(false, 16));
public record U16LiteralNode(List<Token> Tokens, ushort Value) : RValueExpressionNode(Tokens, new NubIntType(false, 16))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record U32LiteralNode(List<Token> Tokens, uint Value) : RValueExpressionNode(Tokens, new NubIntType(false, 32));
public record U32LiteralNode(List<Token> Tokens, uint Value) : RValueExpressionNode(Tokens, new NubIntType(false, 32))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record U64LiteralNode(List<Token> Tokens, ulong Value) : RValueExpressionNode(Tokens, new NubIntType(false, 64));
public record U64LiteralNode(List<Token> Tokens, ulong Value) : RValueExpressionNode(Tokens, new NubIntType(false, 64))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record Float32LiteralNode(List<Token> Tokens, float Value) : RValueExpressionNode(Tokens, new NubFloatType(32));
public record Float32LiteralNode(List<Token> Tokens, float Value) : RValueExpressionNode(Tokens, new NubFloatType(32))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record Float64LiteralNode(List<Token> Tokens, double Value) : RValueExpressionNode(Tokens, new NubFloatType(64));
public record Float64LiteralNode(List<Token> Tokens, double Value) : RValueExpressionNode(Tokens, new NubFloatType(64))
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record BoolLiteralNode(List<Token> Tokens, NubType Type, bool Value) : RValueExpressionNode(Tokens, Type);
public record BoolLiteralNode(List<Token> Tokens, NubType Type, bool Value) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record BinaryExpressionNode(List<Token> Tokens, NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Tokens, Type);
public record BinaryExpressionNode(List<Token> Tokens, NubType Type, ExpressionNode Left, BinaryOperator Operator, ExpressionNode Right) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Left;
yield return Right;
}
}
public record UnaryExpressionNode(List<Token> Tokens, NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Tokens, Type);
public record UnaryExpressionNode(List<Token> Tokens, NubType Type, UnaryOperator Operator, ExpressionNode Operand) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Operand;
}
}
public record FuncCallNode(List<Token> Tokens, NubType Type, ExpressionNode Expression, List<ExpressionNode> Parameters) : RValueExpressionNode(Tokens, Type);
public record FuncCallNode(List<Token> Tokens, NubType Type, ExpressionNode Expression, List<ExpressionNode> Parameters) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Expression;
foreach (var expressionNode in Parameters)
{
yield return expressionNode;
}
}
}
public record VariableIdentifierNode(List<Token> Tokens, NubType Type, string Name) : LValueExpressionNode(Tokens, Type);
public record VariableIdentifierNode(List<Token> Tokens, NubType Type, string Name) : LValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record FuncIdentifierNode(List<Token> Tokens, NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Tokens, Type);
public record FuncIdentifierNode(List<Token> Tokens, NubType Type, string Module, string Name, string? ExternSymbol) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record ArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type);
public record ArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
return Values;
}
}
public record ConstArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type);
public record ConstArrayInitializerNode(List<Token> Tokens, NubType Type, List<ExpressionNode> Values) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
return Values;
}
}
public record ArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
public record ArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Target;
yield return Index;
}
}
public record ConstArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
public record ConstArrayIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Target;
yield return Index;
}
}
public record SliceIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type);
public record SliceIndexAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, ExpressionNode Index) : LValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Target;
yield return Index;
}
}
public record AddressOfNode(List<Token> Tokens, NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Tokens, Type);
public record AddressOfNode(List<Token> Tokens, NubType Type, LValueExpressionNode LValue) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return LValue;
}
}
public record StructFieldAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Tokens, Type);
public record StructFieldAccessNode(List<Token> Tokens, NubType Type, ExpressionNode Target, string Field) : LValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Target;
}
}
public record StructInitializerNode(List<Token> Tokens, NubType Type, Dictionary<string, ExpressionNode> Initializers) : RValueExpressionNode(Tokens, Type);
public record StructInitializerNode(List<Token> Tokens, NubType Type, Dictionary<string, ExpressionNode> Initializers) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
foreach (var initializer in Initializers)
{
yield return initializer.Value;
}
}
}
public record DereferenceNode(List<Token> Tokens, NubType Type, ExpressionNode Target) : LValueExpressionNode(Tokens, Type);
public record DereferenceNode(List<Token> Tokens, NubType Type, ExpressionNode Target) : LValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Target;
}
}
public record ConvertIntNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth, bool StartSignedness, bool TargetSignedness) : RValueExpressionNode(Tokens, new NubIntType(TargetSignedness, TargetWidth));
public record ConvertIntNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth, bool StartSignedness, bool TargetSignedness) : RValueExpressionNode(Tokens, new NubIntType(TargetSignedness, TargetWidth))
{
public override IEnumerable<Node> Children()
{
yield return Value;
}
}
public record ConvertFloatNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth) : RValueExpressionNode(Tokens, new NubFloatType(TargetWidth));
public record ConvertFloatNode(List<Token> Tokens, ExpressionNode Value, int StartWidth, int TargetWidth) : RValueExpressionNode(Tokens, new NubFloatType(TargetWidth))
{
public override IEnumerable<Node> Children()
{
yield return Value;
}
}
public record ConvertCStringToStringNode(List<Token> Tokens, ExpressionNode Value) : RValueExpressionNode(Tokens, new NubStringType());
public record ConvertCStringToStringNode(List<Token> Tokens, ExpressionNode Value) : RValueExpressionNode(Tokens, new NubStringType())
{
public override IEnumerable<Node> Children()
{
yield return Value;
}
}
public record SizeBuiltinNode(List<Token> Tokens, NubType Type, NubType TargetType) : RValueExpressionNode(Tokens, Type);
public record SizeBuiltinNode(List<Token> Tokens, NubType Type, NubType TargetType) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
public record FloatToIntBuiltinNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type);
public record FloatToIntBuiltinNode(List<Token> Tokens, NubType Type, ExpressionNode Value, NubFloatType ValueType, NubIntType TargetType) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Value;
}
}
public record ConstArrayToSliceNode(List<Token> Tokens, NubType Type, ExpressionNode Array) : RValueExpressionNode(Tokens, Type);
public record ConstArrayToSliceNode(List<Token> Tokens, NubType Type, ExpressionNode Array) : RValueExpressionNode(Tokens, Type)
{
public override IEnumerable<Node> Children()
{
yield return Array;
}
}
public record EnumReferenceIntermediateNode(List<Token> Tokens, string Module, string Name) : IntermediateExpression(Tokens);
public record EnumReferenceIntermediateNode(List<Token> Tokens, string Module, string Name) : IntermediateExpression(Tokens)
{
public override IEnumerable<Node> Children()
{
return [];
}
}
#endregion

BIN
vscode-lsp/server/nublsp
View File

Binary file not shown.