commit 23be8ceb027dca23e66f3f45fb365de4b0e9428b · jonmsterling.com/swift-pterodactyl

+7 -7

Sources/PterodactylBuild/BuildContext.swift

···

       38
        
       

     

       39
        
       extension LLBCASFileTree {

     

       40
        
       	static func load<X: FXKey>(id: LLBDataID, in ctx: BuildContext<X>) async throws -> LLBCASFileTree {

     

       41
       -
           try await load(id: id, from: ctx.db, ctx.context).get()

     

       42
        
       	}

     

       43
        
       

     

       44
       -
         func remove<X: FXKey>(path: AbsolutePath, in ctx: BuildContext<X>) async throws -> LLBCASFileTree {

     

       45
       -
           try await remove(path: path, in: ctx.db, ctx.context).get()

     

       46
       -
         }

     

       47
        
       

     

       48
       -
         func traverse<X: FXKey>(root: AbsolutePath, in ctx: BuildContext<X>, _ callback: (AbsolutePath, LLBDataID, LLBDirectoryEntry) async throws -> Void) async throws {

     

       49
       -
           try await traverse(root: root, in: ctx.db, ctx.context, callback)

     

       50
       -
         }

     

       51
        
       }

···

       38
        
       

     

       39
        
       extension LLBCASFileTree {

     

       40
        
       	static func load<X: FXKey>(id: LLBDataID, in ctx: BuildContext<X>) async throws -> LLBCASFileTree {

     

       41
       +
       		try await load(id: id, from: ctx.db, ctx.context).get()

     

       42
        
       	}

     

       43
        
       

     

       44
       +
       	func remove<X: FXKey>(path: AbsolutePath, in ctx: BuildContext<X>) async throws -> LLBCASFileTree {

     

       45
       +
       		try await remove(path: path, in: ctx.db, ctx.context).get()

     

       46
       +
       	}

     

       47
        
       

     

       48
       +
       	func traverse<X: FXKey>(root: AbsolutePath, in ctx: BuildContext<X>, _ callback: (AbsolutePath, LLBDataID, LLBDirectoryEntry) async throws -> Void) async throws {

     

       49
       +
       		try await traverse(root: root, in: ctx.db, ctx.context, callback)

     

       50
       +
       	}

     

       51
        
       }

+5 -2

Sources/PterodactylBuild/Keys/Blob/ParseDocument.swift

···

       10
        
       	struct ParseDocument: BuildKey {

     

       11
        
       		let blobId: LLBDataID

     

       12
        
       		

     

       13
       -
       		typealias ValueType = PterodactylSyntax.SyntaxTree

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
        
       		static let versionDependencies: [any FXVersioning.Type] = [ReadContents.self, Tokenise.self]

     

       16
        
       

     
···

       19
        
       			let tokens = try await ctx.request(Tokenise(blobId: blobId))

     

       20
        
       			var parser = Parser(source: code, tokens: tokens)

     

       21
        
       			PterodactylSyntax.Document.parse(&parser)

     

       22
       -
       			return parser.tree

     

       23
        
       		}

     

       24
        
       	}

     

       25
        
       }

···

       10
        
       	struct ParseDocument: BuildKey {

     

       11
        
       		let blobId: LLBDataID

     

       12
        
       		

     

       13
       +
       		struct ValueType: Codable, FXValue {

     

       14
       +
       			let tree: PterodactylSyntax.SyntaxTree

     

       15
       +
       			let diagnostics: [Diagnostic]

     

       16
       +
       		}

     

       17
        
       

     

       18
        
       		static let versionDependencies: [any FXVersioning.Type] = [ReadContents.self, Tokenise.self]

     

       19
        
       

     
···

       22
        
       			let tokens = try await ctx.request(Tokenise(blobId: blobId))

     

       23
        
       			var parser = Parser(source: code, tokens: tokens)

     

       24
        
       			PterodactylSyntax.Document.parse(&parser)

     

       25
       +
       			return ValueType(tree: parser.tree, diagnostics: parser.diagnostics)

     

       26
        
       		}

     

       27
        
       	}

     

       28
        
       }

-35

Sources/PterodactylBuild/Keys/Blob/ParseImports.swift

···

       27
        
       }

     

       28
        
       

     

       29
        
       

     

       30
       -
       private struct ImportParser {

     

       31
       -
       	private var lexer: PterodactylSyntax.Lexer

     

       32
       -
       	public private(set) var imports: [String] = []

     

       33
        
       

     

       34
       -
       	public init(input: String) {

     

       35
       -
       		self.lexer = PterodactylSyntax.Lexer(input: input)

     

       36
       -
       	}

     

       37
       -
       

     

       38
       -
       	public mutating func parseHeader() {

     

       39
       -
       		while true {

     

       40
       -
       			guard let token = nextSignificantToken() else { return }

     

       41
       -
       			switch token.kind {

     

       42
       -
       			case .keyword(.import): parseImportStatement()

     

       43
       -
       			default: return

     

       44
       -
       			}

     

       45
       -
       		}

     

       46
       -
       	}

     

       47
       -
       

     

       48
       -
       	/// Returns the next non-whitespace token.

     

       49
       -
       	private mutating func nextSignificantToken() -> Token? {

     

       50
       -
       		var token = lexer.nextToken()

     

       51
       -
       		while token?.kind.isTrivia == true {

     

       52
       -
       			token = lexer.nextToken()

     

       53
       -
       		}

     

       54
       -
       		

     

       55
       -
       		guard let token else { return nil}

     

       56
       -
       		return Token(kind: token.kind, text: token.text)

     

       57
       -
       	}

     

       58
       -
       

     

       59
       -
       	/// Parses a single `import xyz` line.

     

       60
       -
       	private mutating func parseImportStatement() {

     

       61
       -
       		guard let next = nextSignificantToken() else { return }

     

       62
       -
       		guard next.kind == .identifier else { return }

     

       63
       -
       		imports.append(next.text)

     

       64
       -
       	}

     

       65
       -
       }

     

       66

+6

Sources/PterodactylBuild/Keys/Blob/README.md

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       Certain operations do not require knowledge of the entire source tree, only a specific blob inside the source tree. These include import analysis, tokenisation, line maps, parsing, etc.

···

       1
       +
       <!--

     

       2
       +
       SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       3
       +
       

     

       4
       +
       SPDX-License-Identifier: MPL-2.0

     

       5
       +
       -->

     

       6
       +
       

     

       7
        
       Certain operations do not require knowledge of the entire source tree, only a specific blob inside the source tree. These include import analysis, tokenisation, line maps, parsing, etc.

+2 -2

Sources/PterodactylBuild/Keys/SourceTree/GetUnitMap.swift

···

       10
        
       		let sourceTreeId: LLBDataID

     

       11
        
       

     

       12
        
       		typealias ValueType = UnitMap

     

       13
       -
       		

     

       14
        
       		func computeValue(_ ctx: BuildContext<Self>) async throws -> UnitMap {

     

       15
        
       			let sourceTree = try await LLBCASFileTree.load(id: sourceTreeId, in: ctx)

     

       16
        
       			var units: [UnitName: UnitInfo] = [:]

     

       17
        
       			try await sourceTree.traverse(root: .root, in: ctx) { path, blobID, directoryEntry in

     

       18
       -
               let unitName = UnitName.fromPath(path)

     

       19
        
       				units[unitName] = UnitInfo(path: path, blobId: blobID)

     

       20
        
       			}

     

       21

···

       10
        
       		let sourceTreeId: LLBDataID

     

       11
        
       

     

       12
        
       		typealias ValueType = UnitMap

     

       13
       +
       

     

       14
        
       		func computeValue(_ ctx: BuildContext<Self>) async throws -> UnitMap {

     

       15
        
       			let sourceTree = try await LLBCASFileTree.load(id: sourceTreeId, in: ctx)

     

       16
        
       			var units: [UnitName: UnitInfo] = [:]

     

       17
        
       			try await sourceTree.traverse(root: .root, in: ctx) { path, blobID, directoryEntry in

     

       18
       +
       				let unitName = UnitName.fromPath(path)

     

       19
        
       				units[unitName] = UnitInfo(path: path, blobId: blobID)

     

       20
        
       			}

     

       21

-53

Sources/PterodactylSyntax/Cursor.swift

···

       1
       -
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       -
       //

     

       3
       -
       // SPDX-License-Identifier: MPL-2.0

     

       4
       -
       

     

       5
       -
       import Foundation

     

       6
       -
       import LanguageServerProtocol

     

       7
       -
       

     

       8
       -
       extension SyntaxTree {

     

       9
       -
       	public final class Cursor {

     

       10
       -
       		public let lineMap: LineMap

     

       11
       -
       		public let node: SyntaxTree.Child

     

       12
       -
       		public let utf16Offset: Int

     

       13
       -
       

     

       14
       -
       		public private(set) lazy var children: [Cursor] = {

     

       15
       -
       			var children: [Cursor] = []

     

       16
       -
       			var utf16Offset = utf16Offset

     

       17
       -
       			for childNode in node.children {

     

       18
       -
       				children.append(Self(lineMap: lineMap, node: childNode, utf16Offset: utf16Offset))

     

       19
       -
       				utf16Offset += childNode.utf16Length

     

       20
       -
       			}

     

       21
       -
       

     

       22
       -
       			return children

     

       23
       -
       		}()

     

       24
       -
       

     

       25
       -
       		public var utf16Range: Range<Int> {

     

       26
       -
       			utf16Offset..<utf16Offset + node.utf16Length

     

       27
       -
       		}

     

       28
       -
       

     

       29
       -
       		init(lineMap: LineMap, node: SyntaxTree.Child, utf16Offset: Int) {

     

       30
       -
       			self.lineMap = lineMap

     

       31
       -
       			self.node = node

     

       32
       -
       			self.utf16Offset = utf16Offset

     

       33
       -
       		}

     

       34
       -
       	}

     

       35
       -
       }

     

       36
       -
       

     

       37
       -
       extension SyntaxTree.Cursor {

     

       38
       -
       	public func firstChild<T>(mapping: (SyntaxTree.Cursor) -> T?) -> T? {

     

       39
       -
       		for child in children {

     

       40
       -
       			if let result = mapping(child) {

     

       41
       -
       				return result

     

       42
       -
       			} else {

     

       43
       -
       				continue

     

       44
       -
       			}

     

       45
       -
       		}

     

       46
       -
       		return nil

     

       47
       -
       	}

     

       48
       -
       	

     

       49
       -
       	public func children<T>(mapping: (SyntaxTree.Cursor) -> T?) -> [T] {

     

       50
       -
       		children.compactMap(mapping)

     

       51
       -
       	}

     

       52
       -
       }

     

       53
       -

+5 -5

Sources/PterodactylSyntax/Diagnostic.swift

···

       2
        
       //

     

       3
        
       // SPDX-License-Identifier: MPL-2.0

     

       4
        
       

     

       5
       -
       public struct Diagnostic: Equatable {

     

       6
       -
       	enum Severity: Equatable {

     

       7
        
       		case error

     

       8
        
       		case warning

     

       9
        
       		case note

     

       10
        
       	}

     

       0
        
       
     

       11
        
       	let message: String

     

       12
        
       	let severity: Severity

     

       13
       -
       	/// Absolute UTF-16 code unit offsets from start of source

     

       14
       -
       	let absoluteRange: Range<Int>

     

       15
        
       

     

       16
        
       	init(message: String, severity: Severity, absoluteRange: Range<Int>) {

     

       17
        
       		self.message = message

     

       18
        
       		self.severity = severity

     

       19
       -
       		self.absoluteRange = absoluteRange

     

       20
        
       	}

     

       21
        
       

     

       22
        
       	init(message: String, absoluteRange: Range<Int>) {

···

       2
        
       //

     

       3
        
       // SPDX-License-Identifier: MPL-2.0

     

       4
        
       

     

       5
       +
       public struct Diagnostic: Equatable, Codable, Sendable {

     

       6
       +
       	enum Severity: Equatable, Codable {

     

       7
        
       		case error

     

       8
        
       		case warning

     

       9
        
       		case note

     

       10
        
       	}

     

       11
       +
       

     

       12
        
       	let message: String

     

       13
        
       	let severity: Severity

     

       14
       +
       	let absoluteUtf16Range: Range<Int>

     

       0
        
       
     

       15
        
       

     

       16
        
       	init(message: String, severity: Severity, absoluteRange: Range<Int>) {

     

       17
        
       		self.message = message

     

       18
        
       		self.severity = severity

     

       19
       +
       		self.absoluteUtf16Range = absoluteRange

     

       20
        
       	}

     

       21
        
       

     

       22
        
       	init(message: String, absoluteRange: Range<Int>) {

+4 -5

Sources/PterodactylSyntax/FoldingRanges.swift

···

       10
        
       	case reverse

     

       11
        
       }

     

       12
        
       

     

       13
       -
       extension Array {

     

       14
       -
       	fileprivate func apply(symmetry: ArraySymmetry) -> any Collection<Element> {

     

       15
        
       		switch symmetry {

     

       16
        
       		case .identity: self

     

       17
        
       		case .reverse: reversed()

     
···

       19
        
       	}

     

       20
        
       }

     

       21
        
       

     

       22
       -
       extension SyntaxTree.Cursor {

     

       23
       -
       	private func firstVisibleNode(under symmetry: ArraySymmetry) -> SyntaxTree.Cursor? {

     

       24
        
       		switch node {

     

       25
        
       		case .token(let token, _):

     

       26
        
       			return token.kind.isVisible ? self : nil

     

       27
        
       		case .tree:

     

       28
        
       			for child in children.apply(symmetry: symmetry) {

     

       29
        
       				if let visibleChild = child.firstVisibleNode(under: symmetry) { return visibleChild }

     

       30
       -
       				continue

     

       31
        
       			}

     

       32
        
       

     

       33
        
       			return nil

···

       10
        
       	case reverse

     

       11
        
       }

     

       12
        
       

     

       13
       +
       fileprivate extension Array {

     

       14
       +
       	func apply(symmetry: ArraySymmetry) -> any Collection<Element> {

     

       15
        
       		switch symmetry {

     

       16
        
       		case .identity: self

     

       17
        
       		case .reverse: reversed()

     
···

       19
        
       	}

     

       20
        
       }

     

       21
        
       

     

       22
       +
       extension SyntaxCursor {

     

       23
       +
       	private func firstVisibleNode(under symmetry: ArraySymmetry) -> SyntaxCursor? {

     

       24
        
       		switch node {

     

       25
        
       		case .token(let token, _):

     

       26
        
       			return token.kind.isVisible ? self : nil

     

       27
        
       		case .tree:

     

       28
        
       			for child in children.apply(symmetry: symmetry) {

     

       29
        
       				if let visibleChild = child.firstVisibleNode(under: symmetry) { return visibleChild }

     

       0
        
       
     

       30
        
       			}

     

       31
        
       

     

       32
        
       			return nil

+11 -5

Sources/PterodactylSyntax/Grammar.swift

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       0
        
       
     

       7
        
       public protocol Grammar: Sendable {

     

       0
        
       
     

       8
        
       	static var kinds: [SyntaxTreeKind] { get }

     

       0
        
       
     

       0
        
       
     

       9
        
       	static func before(_ parser: inout Parser) -> Bool

     

       0
        
       
     

       0
        
       
     

       10
        
       	static func inside(_ parser: inout Parser) -> ParseResult

     

       11
        
       }

     

       12
        
       

     

       13
        
       public struct ParseResult {

     

       14
        
       	public var kind: SyntaxTreeKind

     

       15
        
       	public var metadata: SyntaxTreeMetadata? = nil

     

       16
       -
       	

     

       17
        
       	public init(kind: SyntaxTreeKind, metadata: SyntaxTreeMetadata? = nil) {

     

       18
        
       		self.kind = kind

     

       19
        
       		self.metadata = metadata

     
···

       21
        
       }

     

       22
        
       

     

       23
        
       

     

       24
       -
       public extension Grammar {

     

       25
       -
       	static func tryParse(_ parser: inout Parser) -> Bool {

     

       26
        
       		guard !parser.isEndOfFile && before(&parser) else { return false }

     

       27
        
       		parse(&parser)

     

       28
        
       		return true

     

       29
        
       	}

     

       30
       -
       	

     

       31
       -
       	static func parse(_ parser: inout Parser) {

     

       32
        
       		let mark = parser.open()

     

       33
        
       		let result = inside(&parser)

     

       34
        
       		parser.close(mark: mark, kind: result.kind, metadata: result.metadata)

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       +
       /// This is an abstraction of grammatical productions.

     

       8
        
       public protocol Grammar: Sendable {

     

       9
       +
       	/// The kinds of tree that the production produces.

     

       10
        
       	static var kinds: [SyntaxTreeKind] { get }

     

       11
       +
       

     

       12
       +
       	/// Indicates whether the current parser state is consistent with the grammatical production starting here. When a given grammatical element is optional, this can be used to avoid backtracking. This is a *precondition* for parsing.

     

       13
        
       	static func before(_ parser: inout Parser) -> Bool

     

       14
       +
       

     

       15
       +
       	/// Parse the grammatical production, assuming the precondition indicated by ``before(_:)``. This function should not be called outside this module (instead, use ``parse(_:)`` and ``tryParse(_:)``.

     

       16
        
       	static func inside(_ parser: inout Parser) -> ParseResult

     

       17
        
       }

     

       18
        
       

     

       19
        
       public struct ParseResult {

     

       20
        
       	public var kind: SyntaxTreeKind

     

       21
        
       	public var metadata: SyntaxTreeMetadata? = nil

     

       22
       +
       

     

       23
        
       	public init(kind: SyntaxTreeKind, metadata: SyntaxTreeMetadata? = nil) {

     

       24
        
       		self.kind = kind

     

       25
        
       		self.metadata = metadata

     
···

       27
        
       }

     

       28
        
       

     

       29
        
       

     

       30
       +
       extension Grammar {

     

       31
       +
       	public static func tryParse(_ parser: inout Parser) -> Bool {

     

       32
        
       		guard !parser.isEndOfFile && before(&parser) else { return false }

     

       33
        
       		parse(&parser)

     

       34
        
       		return true

     

       35
        
       	}

     

       36
       +
       

     

       37
       +
       	public static func parse(_ parser: inout Parser) {

     

       38
        
       		let mark = parser.open()

     

       39
        
       		let result = inside(&parser)

     

       40
        
       		parser.close(mark: mark, kind: result.kind, metadata: result.metadata)

+2 -2

Sources/PterodactylSyntax/Grammar/Document/Theory/Declaration.swift

···

       47
        
       }

     

       48
        
       

     

       49
        
       extension SyntaxView<Declaration> {

     

       50
       -
       	var lhs: SyntaxView<Lhs>? { matchingSubview() }

     

       51
       -
       	var rhs: SyntaxView<Rhs>? { matchingSubview() }

     

       52
        
       }

···

       47
        
       }

     

       48
        
       

     

       49
        
       extension SyntaxView<Declaration> {

     

       50
       +
       	var lhs: SyntaxView<Declaration.Lhs>? { matchingSubview() }

     

       51
       +
       	var rhs: SyntaxView<Declaration.Rhs>? { matchingSubview() }

     

       52
        
       }

+13 -11

Sources/PterodactylSyntax/Grammar/Document/Theory/Declaration/Lhs.swift

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       -
       enum Lhs: Grammar {

     

       8
       -
       	static let kind = SyntaxTreeKind(name: "declaration.lhs")

     

       9
       -
       	static let kinds = [kind]

     

       10
       -
       	

     

       11
       -
       	static func before(_ parser: inout Parser) -> Bool {

     

       12
       -
       		parser.isAt(kind: .identifier)

     

       13
       -
       	}

     

       14
       -
       

     

       15
       -
       	static func inside(_ parser: inout Parser) -> ParseResult {

     

       16
       -
       		parser.expect(kind: .identifier, metadata: TokenMetadata(semanticTokenType: .method))

     

       17
       -
       		return ParseResult(kind: Self.kind)

     

       0
        
       
     

       0
        
       
     

       18
        
       	}

     

       19
        
       }

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       +
       extension Declaration {

     

       8
       +
       	enum Lhs: Grammar {

     

       9
       +
       		static let kind = SyntaxTreeKind(name: "declaration.lhs")

     

       10
       +
       		static let kinds = [kind]

     

       11
       +
       		

     

       12
       +
       		static func before(_ parser: inout Parser) -> Bool {

     

       13
       +
       			parser.isAt(kind: .identifier)

     

       14
       +
       		}

     

       15
       +
       		

     

       16
       +
       		static func inside(_ parser: inout Parser) -> ParseResult {

     

       17
       +
       			parser.expect(kind: .identifier, metadata: TokenMetadata(semanticTokenType: .method))

     

       18
       +
       			return ParseResult(kind: Self.kind)

     

       19
       +
       		}

     

       20
        
       	}

     

       21
        
       }

+13 -11

Sources/PterodactylSyntax/Grammar/Document/Theory/Declaration/Rhs.swift

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       -
       enum Rhs: Grammar {

     

       8
       -
       	static let kind = SyntaxTreeKind(name: "declaration.lhs")

     

       9
       -
       	static let kinds = [kind]

     

       10
       -
       	

     

       11
       -
       	static func before(_ parser: inout Parser) -> Bool {

     

       12
       -
       		parser.isAt(kind: .identifier)

     

       13
       -
       	}

     

       14
       -
       

     

       15
       -
       	static func inside(_ parser: inout Parser) -> ParseResult {

     

       16
       -
       		parser.expect(kind: .identifier, metadata: TokenMetadata(semanticTokenType: .method))

     

       17
       -
       		return ParseResult(kind: Self.kind)

     

       0
        
       
     

       0
        
       
     

       18
        
       	}

     

       19
        
       }

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       +
       extension Declaration {

     

       8
       +
       	enum Rhs: Grammar {

     

       9
       +
       		static let kind = SyntaxTreeKind(name: "declaration.lhs")

     

       10
       +
       		static let kinds = [kind]

     

       11
       +
       		

     

       12
       +
       		static func before(_ parser: inout Parser) -> Bool {

     

       13
       +
       			parser.isAt(kind: .identifier)

     

       14
       +
       		}

     

       15
       +
       		

     

       16
       +
       		static func inside(_ parser: inout Parser) -> ParseResult {

     

       17
       +
       			parser.expect(kind: .identifier, metadata: TokenMetadata(semanticTokenType: .method))

     

       18
       +
       			return ParseResult(kind: Self.kind)

     

       19
       +
       		}

     

       20
        
       	}

     

       21
        
       }

+42

Sources/PterodactylSyntax/ImportParser.swift

···

       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       +
       //

     

       3
       +
       // SPDX-License-Identifier: MPL-2.0

     

       4
       +
       

     

       5
       +
       import Foundation

     

       6
       +
       

     

       7
       +
       public struct ImportParser {

     

       8
       +
       	private var lexer: PterodactylSyntax.Lexer

     

       9
       +
       	public private(set) var imports: [String] = []

     

       10
       +
       

     

       11
       +
       	public init(input: String) {

     

       12
       +
       		self.lexer = PterodactylSyntax.Lexer(input: input)

     

       13
       +
       	}

     

       14
       +
       

     

       15
       +
       	public mutating func parseHeader() {

     

       16
       +
       		while true {

     

       17
       +
       			guard let token = nextSignificantToken() else { return }

     

       18
       +
       			switch token.kind {

     

       19
       +
       			case .keyword(.import): parseImportStatement()

     

       20
       +
       			default: return

     

       21
       +
       			}

     

       22
       +
       		}

     

       23
       +
       	}

     

       24
       +
       

     

       25
       +
       	/// Returns the next non-whitespace token.

     

       26
       +
       	private mutating func nextSignificantToken() -> Token? {

     

       27
       +
       		var token = lexer.nextToken()

     

       28
       +
       		while token?.kind.isTrivia == true {

     

       29
       +
       			token = lexer.nextToken()

     

       30
       +
       		}

     

       31
       +
       

     

       32
       +
       		guard let token else { return nil }

     

       33
       +
       		return Token(kind: token.kind, text: token.text)

     

       34
       +
       	}

     

       35
       +
       

     

       36
       +
       	/// Parses a single `import xyz` line.

     

       37
       +
       	private mutating func parseImportStatement() {

     

       38
       +
       		guard let next = nextSignificantToken() else { return }

     

       39
       +
       		guard next.kind == .identifier else { return }

     

       40
       +
       		imports.append(next.text)

     

       41
       +
       	}

     

       42
       +
       }

+1

Sources/PterodactylSyntax/Lexer.swift

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       0
        
       
     

       7
        
       public struct Lexer {

     

       8
        
       	private let input: String

     

       9
        
       	private var index: String.Index

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       +
       /// This tokenises a string, without handling block layout at all. The tokens produced here should be fed into the ``BlockLayoutProcessor``.

     

       8
        
       public struct Lexer {

     

       9
        
       	private let input: String

     

       10
        
       	private var index: String.Index

+1 -1

Sources/PterodactylSyntax/SemanticToken.swift

···

       52
        
       	}

     

       53
        
       }

     

       54
        
       

     

       55
       -
       extension SyntaxTree.Cursor {

     

       56
        
       	var singleLineRanges: [SingleLineRange] {

     

       57
        
       		var result: [SingleLineRange] = []

     

       58
        
       		var location = lineMap.location(at: utf16Offset)

···

       52
        
       	}

     

       53
        
       }

     

       54
        
       

     

       55
       +
       extension SyntaxCursor {

     

       56
        
       	var singleLineRanges: [SingleLineRange] {

     

       57
        
       		var result: [SingleLineRange] = []

     

       58
        
       		var location = lineMap.location(at: utf16Offset)

+51

Sources/PterodactylSyntax/SyntaxCursor.swift

···

       1
       +
       // SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers

     

       2
       +
       //

     

       3
       +
       // SPDX-License-Identifier: MPL-2.0

     

       4
       +
       

     

       5
       +
       import Foundation

     

       6
       +
       import LanguageServerProtocol

     

       7
       +
       

     

       8
       +
       /// This is a “red tree” in the sense of Roslyn. In essence it instruments syntax trees with non-relative location information.

     

       9
       +
       public final class SyntaxCursor {

     

       10
       +
       	public let lineMap: LineMap

     

       11
       +
       	public let node: SyntaxTree.Child

     

       12
       +
       	public let utf16Offset: Int

     

       13
       +
       

     

       14
       +
       	public private(set) lazy var children: [SyntaxCursor] = {

     

       15
       +
       		var children: [SyntaxCursor] = []

     

       16
       +
       		var utf16Offset = utf16Offset

     

       17
       +
       		for childNode in node.children {

     

       18
       +
       			children.append(Self(lineMap: lineMap, node: childNode, utf16Offset: utf16Offset))

     

       19
       +
       			utf16Offset += childNode.utf16Length

     

       20
       +
       		}

     

       21
       +
       

     

       22
       +
       		return children

     

       23
       +
       	}()

     

       24
       +
       

     

       25
       +
       	public var utf16Range: Range<Int> {

     

       26
       +
       		utf16Offset..<utf16Offset + node.utf16Length

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	init(lineMap: LineMap, node: SyntaxTree.Child, utf16Offset: Int) {

     

       30
       +
       		self.lineMap = lineMap

     

       31
       +
       		self.node = node

     

       32
       +
       		self.utf16Offset = utf16Offset

     

       33
       +
       	}

     

       34
       +
       }

     

       35
       +
       

     

       36
       +
       extension SyntaxCursor {

     

       37
       +
       	public func firstChild<T>(mapping: (SyntaxCursor) -> T?) -> T? {

     

       38
       +
       		for child in children {

     

       39
       +
       			if let result = mapping(child) {

     

       40
       +
       				return result

     

       41
       +
       			} else {

     

       42
       +
       				continue

     

       43
       +
       			}

     

       44
       +
       		}

     

       45
       +
       		return nil

     

       46
       +
       	}

     

       47
       +
       

     

       48
       +
       	public func children<T>(mapping: (SyntaxCursor) -> T?) -> [T] {

     

       49
       +
       		children.compactMap(mapping)

     

       50
       +
       	}

     

       51
       +
       }

+1

Sources/PterodactylSyntax/SyntaxTree.swift

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       0
        
       
     

       7
        
       public struct SyntaxTree: Codable, Sendable {

     

       8
        
       	public let kind: SyntaxTreeKind

     

       9
        
       	public let metadata: SyntaxTreeMetadata?

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       +
       /// This is a “green tree” in the sense of Roslyn.

     

       8
        
       public struct SyntaxTree: Codable, Sendable {

     

       9
        
       	public let kind: SyntaxTreeKind

     

       10
        
       	public let metadata: SyntaxTreeMetadata?

+3 -2

Sources/PterodactylSyntax/SyntaxView.swift

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       0
        
       
     

       7
        
       struct SyntaxView<G: Grammar> {

     

       8
       -
       	let cursor: SyntaxTree.Cursor

     

       9
       -
       	init?(_ cursor: SyntaxTree.Cursor) {

     

       10
        
       		guard let kind = cursor.node.tree?.kind, G.kinds.contains(kind) else { return nil }

     

       11
        
       		self.cursor = cursor

     

       12
        
       	}

···

       4
        
       

     

       5
        
       import Foundation

     

       6
        
       

     

       7
       +
       /// An abstract syntax view around a ``SyntaxCursor``. This is to be populated by extensions targetting specific `G`.

     

       8
        
       struct SyntaxView<G: Grammar> {

     

       9
       +
       	let cursor: SyntaxCursor

     

       10
       +
       	init?(_ cursor: SyntaxCursor) {

     

       11
        
       		guard let kind = cursor.node.tree?.kind, G.kinds.contains(kind) else { return nil }

     

       12
        
       		self.cursor = cursor

     

       13
        
       	}