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