public StackFrameCompilationUnit(StackFrameMethodDeclarationNode methodDeclaration, StackFrameFileInformationNode?fileInformationExpression, StackFrameToken endOfLineToken)
: base(StackFrameKind.CompilationUnit)
{
MethodDeclaration = methodDeclaration;
FileInformationExpression = fileInformationExpression;
EndOfLineToken = endOfLineToken;
}
public StackFrameQualifiedNameNode(StackFrameNameNode left, StackFrameToken dotToken, StackFrameSimpleNameNode right) : base(StackFrameKind.MemberAccess)
{
Debug.Assert(dotToken.Kind == StackFrameKind.DotToken);
Left = left;
DotToken = dotToken;
Right = right;
}
/// <summary>
/// Type arguments for stacks are only valid on method declarations, and can have either '[' or '<' as the
/// starting character depending on output source.
///
/// ex: MyNamespace.MyClass.MyMethod[T](T t)
/// ex: MyNamespace.MyClass.MyMethod<T<(T t)
///
/// Assumes the identifier "MyMethod" has already been parsed, and the type arguments will need to be parsed.
/// </summary>
private Result <StackFrameTypeArgumentList> TryParseTypeArguments()
{
if (!_lexer.ScanCurrentCharAsTokenIfMatch(
kind => kind is StackFrameKind.OpenBracketToken or StackFrameKind.LessThanToken,
out var openToken))
{
return(Result <StackFrameTypeArgumentList> .Empty);
}
var closeBracketKind = openToken.Kind is StackFrameKind.OpenBracketToken
? StackFrameKind.CloseBracketToken
: StackFrameKind.GreaterThanToken;
using var _ = ArrayBuilder <StackFrameNodeOrToken> .GetInstance(out var builder);
var currentIdentifier = _lexer.TryScanIdentifier(scanAtTrivia: false, scanLeadingWhitespace: true, scanTrailingWhitespace: true);
StackFrameToken closeToken = default;
while (currentIdentifier.HasValue && currentIdentifier.Value.Kind == StackFrameKind.IdentifierToken)
{
builder.Add(new StackFrameIdentifierNameNode(currentIdentifier.Value));
if (_lexer.ScanCurrentCharAsTokenIfMatch(closeBracketKind, out closeToken))
{
break;
}
if (!_lexer.ScanCurrentCharAsTokenIfMatch(StackFrameKind.CommaToken, out var commaToken))
{
return(Result <StackFrameTypeArgumentList> .Abort);
}
builder.Add(commaToken);
currentIdentifier = _lexer.TryScanIdentifier();
}
if (builder.Count == 0)
{
return(Result <StackFrameTypeArgumentList> .Abort);
}
if (closeToken.IsMissing)
{
return(Result <StackFrameTypeArgumentList> .Abort);
}
var separatedList = new EmbeddedSeparatedSyntaxNodeList <StackFrameKind, StackFrameNode, StackFrameIdentifierNameNode>(builder.ToImmutable());
return(new StackFrameTypeArgumentList(openToken, separatedList, closeToken));
}
/// <summary>
/// Given an identifier, attempts to parse the type identifier arity for it.
///
/// <code>
/// ex: MyNamespace.MyClass`1.MyMethod()
/// ^--------------------- MyClass would be the identifier passed in
/// ^-------------- Grave token
/// ^------------- Arity token of "1"
/// </code>
/// </summary>
private Result <StackFrameSimpleNameNode> TryScanGenericTypeIdentifier(StackFrameToken identifierToken)
{
if (!_lexer.ScanCurrentCharAsTokenIfMatch(StackFrameKind.GraveAccentToken, out var graveAccentToken))
{
return(new(new StackFrameIdentifierNameNode(identifierToken)));
}
var arity = _lexer.TryScanNumbers();
if (!arity.HasValue)
{
return(Result <StackFrameSimpleNameNode> .Abort);
}
return(new StackFrameGenericNameNode(identifierToken, graveAccentToken, arity.Value));
}
protected StackFrameSimpleNameNode(StackFrameToken identifier, StackFrameKind kind) : base(kind)
{
Debug.Assert(identifier.Kind == StackFrameKind.IdentifierToken);
Identifier = identifier;
}
