SwiftSyntax: for Good and Evil

Transcript

1. SWIFTSYNTAX FOR GOOD AND EVIL
2. SWIFTSYNTAX FOR GOOD AND EVIL EVAL
3. Q. WHAT IS SWIFTSYNTAX?
4. A. A SET OF SWIFT LIBRARIES FOR PARSING, INSPECTING, GENERATING, AND TRANSFORMING SWIFT SOURCE CODE1 1 https://github.com/swiftlang/swift-syntax
5. SWIFTSYNTAX MODULES // From swift-syntax Package.swift .library(name: "SwiftBasicFormat", targets: ["SwiftBasicFormat"]), .library(name: "SwiftCompilerPlugin", targets: ["SwiftCompilerPlugin"]), .library(name: "SwiftDiagnostics", targets: ["SwiftDiagnostics"]), .library(name: "SwiftIDEUtils", targets: ["SwiftIDEUtils"]), .library(name: "SwiftOperators", targets: ["SwiftOperators"]), .library(name: "SwiftParser", targets: ["SwiftParser"]), .library(name: "SwiftParserDiagnostics", targets: ["SwiftParserDiagnostics"]), .library(name: "SwiftRefactor", targets: ["SwiftRefactor"]), .library(name: "SwiftSyntax", targets: ["SwiftSyntax"]), .library(name: "SwiftSyntaxBuilder", targets: ["SwiftSyntaxBuilder"]), .library(name: "SwiftSyntaxMacros", targets: ["SwiftSyntaxMacros"]), .library(name: "SwiftSyntaxMacroExpansion", targets: ["SwiftSyntaxMacroExpansion"]), .library(name: "SwiftSyntaxMacrosTestSupport", targets: ["SwiftSyntaxMacrosTestSupport"]), .library(name: "SwiftSyntaxMacrosGenericTestSupport", targets: ["SwiftSyntaxMacrosGenericTestSupport"]), .library(name: "_SwiftCompilerPluginMessageHandling", targets: ["SwiftCompilerPluginMessageHandling"]), .library(name: "_SwiftLibraryPluginProvider", targets: ["SwiftLibraryPluginProvider"]),
6. SWIFTSYNTAX MODULES // From swift-syntax Package.swift .library(name: "SwiftBasicFormat", targets: ["SwiftBasicFormat"]), .library(name: "SwiftCompilerPlugin", targets: ["SwiftCompilerPlugin"]), .library(name: "SwiftDiagnostics", targets: ["SwiftDiagnostics"]), .library(name: "SwiftIDEUtils", targets: ["SwiftIDEUtils"]), .library(name: "SwiftOperators", targets: ["SwiftOperators"]), .library(name: "SwiftParser", targets: ["SwiftParser"]), .library(name: "SwiftParserDiagnostics", targets: ["SwiftParserDiagnostics"]), .library(name: "SwiftRefactor", targets: ["SwiftRefactor"]), .library(name: "SwiftSyntax", targets: ["SwiftSyntax"]), .library(name: "SwiftSyntaxBuilder", targets: ["SwiftSyntaxBuilder"]), .library(name: "SwiftSyntaxMacros", targets: ["SwiftSyntaxMacros"]), .library(name: "SwiftSyntaxMacroExpansion", targets: ["SwiftSyntaxMacroExpansion"]), .library(name: "SwiftSyntaxMacrosTestSupport", targets: ["SwiftSyntaxMacrosTestSupport"]), .library(name: "SwiftSyntaxMacrosGenericTestSupport", targets: ["SwiftSyntaxMacrosGenericTestSupport"]), .library(name: "_SwiftCompilerPluginMessageHandling", targets: ["SwiftCompilerPluginMessageHandling"]), .library(name: "_SwiftLibraryPluginProvider", targets: ["SwiftLibraryPluginProvider"]),
7. Q. HOW DOES IT WORK?
8. THE SYNTAX TREE
9. THE SYNTAX TREE Tokens Declarations Expressions Statements Source File
10. THE SYNTAX TREE Tokens Declarations Expressions Statements Source File
11. THE SYNTAX TREE Tokens Declarations Expressions Statements Source File
12. THE SYNTAX TREE Tokens Declarations Expressions Statements Source File
13. THE SYNTAX TREE Tokens Declarations Expressions Statements Source File
14. SYNTAX PROTOCOL
15. SYNTAX PROTOCOL Tokens Declarations Expressions Statements Source File
16. SYNTAX PROTOCOL struct TokenSyntax: SyntaxProtocol Declarations Expressions Statements Source File
17. SYNTAX PROTOCOL struct TokenSyntax: SyntaxProtocol struct FunctionDeclSyntax: DeclSyntaxProtocol Expressions Statements Source File
18. SYNTAX PROTOCOL struct TokenSyntax: SyntaxProtocol struct FunctionDeclSyntax: DeclSyntaxProtocol struct TupleExprSyntax: ExprSyntaxProtocol Statements Source File
19. SYNTAX PROTOCOL struct TokenSyntax: SyntaxProtocol struct FunctionDeclSyntax: DeclSyntaxProtocol struct TupleExprSyntax: ExprSyntaxProtocol struct ForStmtSyntax: StmtSyntaxProtcol Source File
20. SYNTAX PROTOCOL struct TokenSyntax: SyntaxProtocol struct FunctionDeclSyntax: DeclSyntaxProtocol struct TupleExprSyntax: ExprSyntaxProtocol struct ForStmtSyntax: StmtSyntaxProtcol struct SourceFileSyntax: SyntaxProtocol
21. Q. WHAT IS IT GOOD FOR?
22. USE CASES ‣Language Features → Conditional compilation, macros
23. USE CASES ‣Language Features → Conditional compilation, macros ‣IDE Tools → Swift migration tool, refactoring, fixits and formatting
24. USE CASES ‣Language Features → Conditional compilation, macros ‣IDE Tools → Swift migration tool, refactoring, fixits and formatting ‣Linting → Detecting style violations and enforcing best practices
25. USE CASES ‣Language Features → Conditional compilation, macros ‣IDE Tools → Swift migration tool, refactoring, fixits and formatting ‣Linting → Detecting style violations and enforcing best practices ‣Static Analysis → Detecting dead code, deprecated APIs, etc.
26. USE CASES ‣Language Features → Conditional compilation, macros ‣IDE Tools → Swift migration tool, refactoring, fixits and formatting ‣Linting → Detecting style violations and enforcing best practices ‣Static Analysis → Detecting dead code, deprecated APIs, etc. ‣Code generation → Creating and modifying source code safely
27. EVAL
28. SWIFT EVAL
29. EVALUATING EXPRESSIONS let source = "1 + 2 * 3"
30. EVALUATING EXPRESSIONS import SwiftParser let source = "1 + 2 * 3"
31. EVALUATING EXPRESSIONS import SwiftParser let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) debugPrint(sourceSyntax)
32. EVALUATING EXPRESSIONS import SwiftParser let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) debugPrint(sourceSyntax) SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: SequenceExprSyntax │ ╰─elements: ExprListSyntax │ ├─[0]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─[1]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ├─[2]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─[3]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─[4]: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
33. EVALUATING EXPRESSIONS import SwiftParser let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) debugPrint(sourceSyntax) SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: SequenceExprSyntax │ ╰─elements: ExprListSyntax │ ├─[0]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─[1]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ├─[2]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─[3]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─[4]: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
34. PROBLEM: OPERATOR SOUP
35. ORDER OF OPERATIONS 1 + 2 * 3
36. ORDER OF OPERATIONS 1 +(2 * 3)
37. CUSTOM OPERATORS // Percentage operator postfix operator % postfix func % (value: Double) -> Double { return value / 100 }
38. CUSTOM OPERATORS // Exponent operator infix operator ^ : MultiplicationPrecedence func ^ (base: Double, exponent: Double) -> Double { return pow(base, exponent) }
39. SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: SequenceExprSyntax │ ╰─elements: ExprListSyntax │ ├─[0]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─[1]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ├─[2]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─[3]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─[4]: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
40. SOLUTION: SWIFTOPERATORS
41. SWIFTOPERATORS import SwiftParser import SwiftOperators let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) debugPrint(sourceSyntax)
42. SWIFTOPERATORS import SwiftParser import SwiftOperators let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) debugPrint(sourceSyntax)
43. SWIFTOPERATORS import SwiftParser import SwiftOperators let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) let operatorTable = OperatorTable let foldedSyntax = try operatorTable.foldAll(sourceSyntax) debugPrint(sourceSyntax)
44. SWIFTOPERATORS import SwiftParser import SwiftOperators let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) debugPrint(sourceSyntax)
45. SWIFTOPERATORS import SwiftParser import SwiftOperators let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) debugPrint(foldedSyntax)
46. SWIFTOPERATORS import SwiftSyntax import SwiftParser import SwiftOperators let source = "1 + 2 * 3" let sourceSyntax = Parser.parse(source: source) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) debugPrint(foldedSyntax) SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ╰─rightOperand: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─rightOperand: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
47. SWIFTOPERATORS SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: SequenceExprSyntax → │ ╰─elements: ExprListSyntax │ ├─[0]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─[1]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ├─[2]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─[3]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─[4]: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ╰─rightOperand: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─rightOperand: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
48. SWIFTOPERATORS SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: SequenceExprSyntax → │ ╰─elements: ExprListSyntax │ ├─[0]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─[1]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ├─[2]: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─[3]: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─[4]: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ╰─rightOperand: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─rightOperand: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
49. INTERPRETER
50. INTERPRETER class Interpreter { private var result: Double = .nan func evaluate( _ syntax: SyntaxProtocol) -> Double { result = .nan // TODO return result } }
51. INTERPRETER class Interpreter { private var result: Double = .nan func evaluate( _ syntax: SyntaxProtocol) -> Double { result = .nan // TODO return result } }
52. INTERPRETER class Interpreter { private var result: Double = .nan func evaluate( _ syntax: SyntaxProtocol ) -> Double { result = .nan // TODO return result } } SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ╰─rightOperand: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─rightOperand: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
53. INTERPRETER class Interpreter { private var result: Double = .nan func evaluate( _ syntax: SyntaxProtocol ) -> Double { result = .nan // TODO return result } } SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ╰─rightOperand: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─rightOperand: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
54. SYNTAX VISITOR
55. SYNTAX VISITOR open class SyntaxVisitor
56. SYNTAX VISITOR open class SyntaxVisitor { public func walk(_ node: some SyntaxProtocol) } // Usage let syntaxTree = Parser.parse(source: source) let visitor = MySyntaxVisitor(viewMode: .fixedUp) visitor.walk(syntaxTree)
57. SYNTAX VISITOR open class SyntaxVisitor { public func walk(_ node: some SyntaxProtocol) open func visit(_ node: AccessorBlockSyntax) open func visit(_ node: AccessorDeclListSyntax) open func visit(_ node: AccessorEffectSpeci...) open func visit(_ node: AccessorParametersSyntax) open func visit(_ node: ActorDeclSyntax) ...
58. INTERPRETER import SwiftSyntax class Interpreter { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan // TODO return result } }
59. INTERPRETER import SwiftSyntax class Interpreter: SyntaxVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan // TODO return result } }
60. INTERPRETER import SwiftSyntax class Interpreter: SyntaxVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } }
61. import SwiftSyntax class Interpreter: SyntaxVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } }
62. import SwiftSyntax class Interpreter: SyntaxVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } }
63. import SwiftSyntax class Interpreter: SyntaxVisitor { ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) switch node.operator.trimmedDescription { case "+": result = lhs + rhs case "-": result = lhs - rhs case "*": result = lhs * rhs case "/": result = lhs / rhs default: break } return .skipChildren } }
64. REPL
65. import SwiftParser import SwiftOperators print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
66. import SwiftParser import SwiftOperators print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
67. import SwiftParser import SwiftOperators print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
68. import SwiftParser import SwiftOperators print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
87. private class ExpressionEvaluator: SyntaxVisitor { var result: Double = .nan ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) switch node.operator.trimmedDescription { case "+": result = lhs + rhs case "-": result = lhs - rhs case "*": result = lhs * rhs case "/": result = lhs / rhs default: break } return .skipChildren } } Type expressions to see the result. Type 'exit' to quit. > 1 + 2 = 3.0 > 2 + 3 * 4 = 14.0 > 1 / 2 = 0.5 > 1 / 0 = inf > 1 + 2.5 = nan > 3 + * 4 = nan > 3 ++ 4 Swift/ErrorType.swift:253: Fatal error: Error raised at top level: SwiftOperators.OperatorError.missingOperator( "++", referencedFrom: binaryOperator("++"))
88. private class ExpressionEvaluator: SyntaxVisitor { var result: Double = .nan ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) switch node.operator.trimmedDescription { case "+": result = lhs + rhs case "-": result = lhs - rhs case "*": result = lhs * rhs case "/": result = lhs / rhs default: break } return .skipChildren } } Type expressions to see the result. Type 'exit' to quit. > 1 + 2 = 3.0 > 2 + 3 * 4 = 14.0 > 1 / 2 = 0.5 > 1 / 0 = inf > 1 + 2.5 = nan > 3 + * 4 = nan > 3 ++ 4 Swift/ErrorType.swift:253: Fatal error: Error raised at top level: SwiftOperators.OperatorError.missingOperator( "++", referencedFrom: binaryOperator("++"))
89. private class ExpressionEvaluator: SyntaxVisitor { var result: Double = .nan ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) switch node.operator.trimmedDescription { case "+": result = lhs + rhs case "-": result = lhs - rhs case "*": result = lhs * rhs case "/": result = lhs / rhs default: break } return .skipChildren } } Type expressions to see the result. Type 'exit' to quit. > 1 + 2 = 3.0 > 2 + 3 * 4 = 14.0 > 1 / 2 = 0.5 > 1 / 0 = inf > 1 + 2.5 = nan > 3 + * 4 = nan > 3 ++ 4 Swift/ErrorType.swift:253: Fatal error: Error raised at top level: SwiftOperators.OperatorError.missingOperator( "++", referencedFrom: binaryOperator("++"))
90. private class ExpressionEvaluator: SyntaxVisitor { var result: Double = .nan ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) ... return .skipChildren } } Type expressions to see the result. Type 'exit' to quit. > 1 + 2 = 3.0 > 2 + 3 * 4 = 14.0 > 1 / 2 = 0.5 > 1 / 0 = inf > 1 + 2.5 = nan > 3 + * 4 = nan > 3 ++ 4 Swift/ErrorType.swift:253: Fatal error: Error raised at top level: SwiftOperators.OperatorError.missingOperator( "++", referencedFrom: binaryOperator("++"))
91. private class ExpressionEvaluator: SyntaxVisitor { var result: Double = .nan ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) ... return .skipChildren } } Type expressions to see the result. Type 'exit' to quit. > 1 + 2 = 3.0 > 2 + 3 * 4 = 14.0 > 1 / 2 = 0.5 > 1 / 0 = inf > 1 + 2.5 = nan > 3 + * 4 = nan > 3 ++ 4 Swift/ErrorType.swift:253: Fatal error: Error raised at top level: SwiftOperators.OperatorError.missingOperator( "++", referencedFrom: binaryOperator("++"))
92. import SwiftSyntax import SwiftParser import SwiftOperators print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
93. import SwiftSyntax import SwiftParser import SwiftOperators print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
94. ERROR RECOVERY UnexpectedNodesSyntax // For input that couldn't be parsed MissingSyntax // For missing nodes MissingStmtSyntax MissingDeclSyntax MissingTypeSyntax MissingExprSyntax etc... extension TokenSyntax { var presence: SourcePresence // present or missing }
95. ERROR RECOVERY UnexpectedNodesSyntax // For input that couldn't be parsed MissingSyntax // For missing nodes MissingStmtSyntax MissingDeclSyntax MissingTypeSyntax MissingExprSyntax etc... extension TokenSyntax { var presence: SourcePresence // present or missing }
96. ERROR RECOVERY UnexpectedNodesSyntax // For input that couldn't be parsed MissingSyntax // For missing nodes MissingStmtSyntax MissingDeclSyntax MissingTypeSyntax MissingExprSyntax etc... extension TokenSyntax { var presence: SourcePresence // present or missing }
97. ERROR RECOVERY UnexpectedNodesSyntax // For input that couldn't be parsed MissingSyntax // For missing nodes MissingStmtSyntax MissingDeclSyntax MissingTypeSyntax MissingExprSyntax etc... extension TokenSyntax { var presence: SourcePresence // present or missing }
98. VIEWMODE open class SyntaxVisitor { public init(viewMode: SyntaxTreeViewMode) { ... } } public enum SyntaxTreeViewMode: Sendable { /// Visit only the nodes present in the original source code case sourceAccurate /// Missing nodes will be visited, unexpected nodes will be skipped case fixedUp /// Both missing and unexpected nodes will be traversed case all }
99. VIEWMODE open class SyntaxVisitor { public init(viewMode: SyntaxTreeViewMode) { ... } } public enum SyntaxTreeViewMode: Sendable { /// Visit only the nodes present in the original source code case sourceAccurate /// Missing nodes will be visited, unexpected nodes will be skipped case fixedUp /// Both missing and unexpected nodes will be traversed case all }
100. VIEWMODE open class SyntaxVisitor { public init(viewMode: SyntaxTreeViewMode) { ... } } public enum SyntaxTreeViewMode: Sendable { /// Visit only the nodes present in the original source code case sourceAccurate /// Missing nodes will be visited, unexpected nodes will be skipped case fixedUp /// Both missing and unexpected nodes will be traversed case all }
101. PARSER DIAGNOSTICS
102. import SwiftParser import SwiftOperators print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
103. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
104. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParserDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
105. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParserDiagnosticsGenerator.diagnostics(for: sourceSyntax) for diagnostic in diagnostics { print(diagnostic) } let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
106. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParserDiagnosticsGenerator.diagnostics(for: sourceSyntax) for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
107. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParserDiagnosticsGenerator.diagnostics(for: sourceSyntax) for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
114. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParserDiagnosticsGenerator.diagnostics(for: sourceSyntax) for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
115. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParserDiagnosticsGenerator.diagnostics(for: sourceSyntax) for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
116. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParserDiagnosticsGenerator.diagnostics(for: sourceSyntax) for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
117. OPERATOR ERROR extension OperatorTable { public func foldAll( _ node: some SyntaxProtocol, errorHandler: OperatorErrorHandler = { throw $0 } ) rethrows -> Syntax } extension OperatorError { /// Produce a diagnostic for a given operator-precedence error. public var asDiagnostic: Diagnostic }
118. OPERATOR ERROR extension OperatorTable { public func foldAll( _ node: some SyntaxProtocol, errorHandler: OperatorErrorHandler = { throw $0 } ) rethrows -> Syntax } extension OperatorError { /// Produce a diagnostic for a given operator-precedence error. public var asDiagnostic: Diagnostic }
119. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) let diagnostics = ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = try operatorTable.foldAll(sourceSyntax) for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
120. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
126. SYNTAX ANY VISITOR
127. SYNTAX ANY VISITOR /// A SyntaxVisitor that can visit the nodes as generic Syntax values. /// /// This subclass of SyntaxVisitor is slower than the type-specific visitation /// of SyntaxVisitor. Use SyntaxAnyVisitor if the visitAny(_) function /// would be useful to have, otherwise inherit from SyntaxVisitor. /// open class SyntaxAnyVisitor: SyntaxVisitor { open func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { return .visitChildren } ... }
128. INTERPRETER class Interpreter: SyntaxVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } ... }
129. INTERPRETER class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } ... }
130. INTERPRETER class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } ... }
131. INTERPRETER class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { result = .nan return .visitChildren } }
137. CUSTOM DIAGNOSTICS
138. DIAGNOSTIC public struct Diagnostic: CustomDebugStringConvertible, Sendable { public init( node: some SyntaxProtocol, position: AbsolutePosition? = nil, message: DiagnosticMessage, highlights: [Syntax]? = nil, notes: [Note] = [], fixIts: [FixIt] = [] ) }
139. DIAGNOSTIC public struct Diagnostic: CustomDebugStringConvertible, Sendable { public init( node: some SyntaxProtocol, position: AbsolutePosition? = nil, message: DiagnosticMessage, highlights: [Syntax]? = nil, notes: [Note] = [], fixIts: [FixIt] = [] ) }
140. DIAGNOSTIC public struct Diagnostic: CustomDebugStringConvertible, Sendable { public init( node: some SyntaxProtocol, position: AbsolutePosition? = nil, message: DiagnosticMessage, highlights: [Syntax]? = nil, notes: [Note] = [], fixIts: [FixIt] = [] ) }
141. DIAGNOSTIC public protocol DiagnosticMessage: Sendable { /// The diagnostic message that should be displayed in the client. var message: String { get } var diagnosticID: MessageID { get } var severity: DiagnosticSeverity { get } }
142. import SwiftDiagnostics class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan ... override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { result = .nan return .visitChildren } }
143. import SwiftDiagnostics struct Message: DiagnosticMessage { var message: String var severity: DiagnosticSeverity = .error var diagnosticID: MessageID { .init(domain: "Interpreter", id: message) } } class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan ... override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { result = .nan return .visitChildren } }
144. import SwiftDiagnostics struct Message: DiagnosticMessage { var message: String var severity: DiagnosticSeverity = .error var diagnosticID: MessageID { .init(domain: "Interpreter", id: message) } } extension SyntaxProtocol { func error(_ message: String) -> Diagnostic { .init(node: self, message: Message(message: message)) } } class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan ... override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { result = .nan return .visitChildren } }
145. import SwiftDiagnostics struct Message: DiagnosticMessage { var message: String var severity: DiagnosticSeverity = .error var diagnosticID: MessageID { .init(domain: "Interpreter", id: message) } } extension SyntaxProtocol { func error(_ message: String) -> Diagnostic { .init(node: self, message: Message(message: message)) } } class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan var diagnostics: [Diagnostic] = [] ... override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { result = .nan return .visitChildren } }
146. import SwiftDiagnostics struct Message: DiagnosticMessage { var message: String var severity: DiagnosticSeverity = .error var diagnosticID: MessageID { .init(domain: "Interpreter", id: message) } } extension SyntaxProtocol { func error(_ message: String) -> Diagnostic { .init(node: self, message: Message(message: message)) } } class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan var diagnostics: [Diagnostic] = [] ... override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax: '\(node.kind)'")) return .visitChildren } }
147. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } let result = interpreter.evaluate(foldedSyntax) print("= \(result)") }
148. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } print("= \(result)") }
149. import SwiftParser import SwiftOperators import SwiftParserDiagnostics print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) diagnostics += result.diagnostics result.diagnostics.removeAll() for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } print("= \(result)") }
155. SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ╰─rightOperand: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─rightOperand: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
156. SourceFileSyntax ├─statements: CodeBlockItemListSyntax │ ╰─[0]: CodeBlockItemSyntax │ ╰─item: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("1") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("+") │ ╰─rightOperand: InfixOperatorExprSyntax │ ├─leftOperand: IntegerLiteralExprSyntax │ │ ╰─literal: integerLiteral("2") │ ├─operator: BinaryOperatorExprSyntax │ │ ╰─operator: binaryOperator("*") │ ╰─rightOperand: IntegerLiteralExprSyntax │ ╰─literal: integerLiteral("3") ╰─endOfFileToken: endOfFile
157. class Interpreter: SyntaxAnyVisitor { ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax: '\(node.kind)'")) return .visitChildren } }
158. class Interpreter: SyntaxAnyVisitor { ... override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { ... } override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax: '\(node.kind)'")) return .visitChildren } // MARK: Ignored override open func visit(_ token: SourceFileSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } override open func visit(_ token: CodeBlockItemListSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } override open func visit(_ token: CodeBlockItemSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } override open func visit(_ token: TokenSyntax) -> SyntaxVisitorContinueKind { return .visitChildren } }
168. TYPES & VARIABLES
169. enum Variant: Equatable { case undefined case number(Double) case boolean(Bool) case string(String) } extension Variant: CustomStringConvertible { var description: String { switch self { case .undefined: "undefined" case let .number(value): "\(value)" case let .boolean(value): "\(value)" case let .string(value): value } } } class Interpreter: SyntaxAnyVisitor { private var result: Double = .nan var diagnostics: [Diagnostic] = [] func evaluate(_ syntax: SyntaxProtocol) -> Double { result = .nan walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = Double(node.literal.text) ?? .nan return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) switch node.operator.trimmedDescription { case "+": result = lhs + rhs case "-": result = lhs - rhs case "*": result = lhs * rhs case "/": result = lhs / rhs default: break } return .skipChildren } ... }
170. enum Variant: Equatable { case undefined case number(Double) case boolean(Bool) case string(String) } extension Variant: CustomStringConvertible { var description: String { switch self { case .undefined: "undefined" case let .number(value): "\(value)" case let .boolean(value): "\(value)" case let .string(value): value } } } class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined var diagnostics: [Diagnostic] = [] func evaluate(_ syntax: SyntaxProtocol) -> Variant { result = .undefined walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = .number(Double(node.literal.text) ?? .nan) return .skipChildren } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = .number(Double(node.literal.text) ?? .nan) return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) switch (lhs, rhs, node.operator.trimmedDescription) { case let (.number(l), .number(r), "+"): result = .number(l + r) case let (.number(l), .number(r), "-"): result = .number(l - r) case let (.number(l), .number(r), "*"): result = .number(l * r) case let (.number(l), .number(r), "/"): result = .number(l / r) default: diagnostics.append(node.error("invalid expression: \(node.trimmed)")) } return .skipChildren } ... }
171. enum Variant: Equatable { case undefined case number(Double) case boolean(Bool) case string(String) } extension Variant: CustomStringConvertible { var description: String { switch self { case .undefined: "undefined" case let .number(value): "\(value)" case let .boolean(value): "\(value)" case let .string(value): value } } } class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined private var variables: [String: Variant] = [:] var diagnostics: [Diagnostic] = [] func evaluate(_ syntax: SyntaxProtocol) -> Variant { result = .undefined walk(syntax) return result } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = .number(Double(node.literal.text) ?? .nan) return .skipChildren } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = .number(Double(node.literal.text) ?? .nan) return .skipChildren } override func visit(_ node: InfixOperatorExprSyntax) -> SyntaxVisitorContinueKind { let lhs = evaluate(node.leftOperand) let rhs = evaluate(node.rightOperand) switch (lhs, rhs, node.operator.trimmedDescription) { case let (.number(l), .number(r), "+"): result = .number(l + r) case let (.number(l), .number(r), "-"): result = .number(l - r) case let (.number(l), .number(r), "*"): result = .number(l * r) case let (.number(l), .number(r), "/"): result = .number(l / r) default: diagnostics.append(node.error("invalid expression: \(node.trimmed)")) } return .skipChildren } ... }
172. enum Variant: Equatable { case undefined case number(Double) case boolean(Bool) case string(String) } extension Variant: CustomStringConvertible { var description: String { switch self { case .undefined: "undefined" case let .number(value): "\(value)" case let .boolean(value): "\(value)" case let .string(value): value } } } class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined private var variables: [String: Variant] = [:] var diagnostics: [Diagnostic] = [] func evaluate(_ syntax: SyntaxProtocol) -> Variant { ... } override func visit(_ node: DeclReferenceExprSyntax) -> SyntaxVisitorContinueKind { if let value = variables[node.baseName.text] { result = value } else { result = .undefined diagnostics.append(node.error("undefined variable '\(node.trimmed)'")) } return .skipChildren } override func visit(_ node: IntegerLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = .number(Double(node.literal.text) ?? .nan) return .skipChildren } override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = .number(Double(node.literal.text) ?? .nan) return .skipChildren } override func visit(_ node: BooleanLiteralExprSyntax) -> SyntaxVisitorContinueKind { result = .boolean(node.literal.tokenKind == .keyword(.true)) return .skipChildren } ... }
173. enum Variant: Equatable { case undefined case number(Double) case boolean(Bool) case string(String) } extension Variant: CustomStringConvertible { var description: String { switch self { case .undefined: "undefined" case let .number(value): "\(value)" case let .boolean(value): "\(value)" case let .string(value): value } } } class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined private var variables: [String: Variant] = [:] var diagnostics: [Diagnostic] = [] func evaluate(_ syntax: SyntaxProtocol) -> Variant { ... } override func visit(_ node: DeclReferenceExprSyntax) -> SyntaxVisitorContinueKind { if let value = variables[node.baseName.text] { result = value } else { result = .undefined diagnostics.append(node.error("undefined variable '\(node.trimmed)'")) } return .skipChildren } override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind { for binding in node.bindings { switch binding.pattern.as(PatternSyntaxEnum.self) { case let .identifierPattern(identifier): let value = binding.initializer.map { evaluate($0.value) } variables[identifier.identifier.text] = value ?? .undefined default: diagnostics.append( node.error("unsupported syntax '\(binding.pattern.trimmed)'") ) } } return .skipChildren } ... }
174. SKIPPING AHEAD...
196. class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined private var variables: [String: Variant] = [:] var diagnostics: [Diagnostic] = [] ... override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind { for binding in node.bindings { switch binding.pattern.as(PatternSyntaxEnum.self) { case let .identifierPattern(identifier): let value = binding.initializer.map { evaluate($0.value) } variables[identifier.identifier.text] = value ?? .undefined default: diagnostics.append(node.error("unsupported syntax '\(binding.pattern.kind)'")) } } return .skipChildren } override func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind { variables[node.name.text] = .function(node) return .skipChildren } override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.kind)'")) return .visitChildren } ... }
197. class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined private var variables: [String: Variant] = [:] var diagnostics: [Diagnostic] = [] ... override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind { for binding in node.bindings { switch binding.pattern.as(PatternSyntaxEnum.self) { case let .identifierPattern(identifier): let value = binding.initializer.map { evaluate($0.value) } variables[identifier.identifier.text] = value ?? .undefined default: diagnostics.append(node.error("unsupported syntax '\(binding.pattern.kind)'")) } } return .skipChildren } override func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind { variables[node.name.text] = .function(node) return .skipChildren } override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.kind)'")) return .visitChildren } ... }
198. class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined private var variables: [String: Variant] = [:] var diagnostics: [Diagnostic] = [] ... override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind { for binding in node.bindings { switch binding.pattern.as(PatternSyntaxEnum.self) { case let .identifierPattern(identifier): let value = binding.initializer.map { evaluate($0.value) } variables[identifier.identifier.text] = value ?? .undefined default: diagnostics.append(node.error("unsupported syntax '\(binding.pattern.kind)'")) } } return .skipChildren } override func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind { variables[node.name.text] = .function(node) return .skipChildren } override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.kind)'")) return .visitChildren } ... }
199. class Interpreter: SyntaxAnyVisitor { private var result: Variant = .undefined private var variables: [String: Variant] = [:] var diagnostics: [Diagnostic] = [] ... override func visit(_ node: VariableDeclSyntax) -> SyntaxVisitorContinueKind { for binding in node.bindings { switch binding.pattern.as(PatternSyntaxEnum.self) { case let .identifierPattern(identifier): let value = binding.initializer.map { evaluate($0.value) } variables[identifier.identifier.text] = value ?? .undefined default: diagnostics.append(node.error("unsupported syntax '\(binding.pattern.kind)'")) } } return .skipChildren } override func visit(_ node: FunctionDeclSyntax) -> SyntaxVisitorContinueKind { variables[node.name.text] = .function(node) return .skipChildren } override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.kind)'")) return .visitChildren } ... }
200. PREPROCESSOR
201. class Preprocessor: SyntaxVisitor { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
202. class Preprocessor: SyntaxVisitor { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
203. class Preprocessor: SyntaxVisitor { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
204. class Preprocessor: SyntaxVisitor { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
205. class Preprocessor: SyntaxVisitor { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
206. class Preprocessor: SyntaxVisitor { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
207. print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) diagnostics += interpreter.diagnostics interpreter.diagnostics.removeAll() for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } if result != .undefined { print("= \(result)") } }
208. print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) diagnostics += interpreter.diagnostics interpreter.diagnostics.removeAll() for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } if result != .undefined { print("= \(result)") } }
209. print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = Preprocessor.diagnostics(for: sourceSyntax) diagnostics += ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) diagnostics += interpreter.diagnostics interpreter.diagnostics.removeAll() for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } if result != .undefined { print("= \(result)") } }
219. SYNTAX REWRITER
220. class Preprocessor: SyntaxVisitor { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
221. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
222. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: ReturnClauseSyntax) -> SyntaxVisitorContinueKind { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return .skipChildren } override func visit(_ node: FunctionParameterSyntax) -> SyntaxVisitorContinueKind { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return .skipChildren } }
223. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> TypeAnnotationSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: ReturnClauseSyntax) -> ReturnClauseSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: FunctionParameterSyntax) -> FunctionParameterSyntax { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return node } }
224. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> TypeAnnotationSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: ReturnClauseSyntax) -> ReturnClauseSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: FunctionParameterSyntax) -> FunctionParameterSyntax { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return node } }
225. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> TypeAnnotationSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: ReturnClauseSyntax) -> ReturnClauseSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: FunctionParameterSyntax) -> FunctionParameterSyntax { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return node .with(\.colon.presence, .present) } }
226. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> TypeAnnotationSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: ReturnClauseSyntax) -> ReturnClauseSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: FunctionParameterSyntax) -> FunctionParameterSyntax { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return node .with(\.colon.presence, .present) .with(\.type, TypeSyntax( IdentifierTypeSyntax(name: .identifier("Any"), trailingTrivia: .space) )) } }
227. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func diagnostics(for syntax: SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor(viewMode: .sourceAccurate) processor.walk(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> TypeAnnotationSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: ReturnClauseSyntax) -> ReturnClauseSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: FunctionParameterSyntax) -> FunctionParameterSyntax { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return node .with(\.colon.presence, .present) .with(\.type, TypeSyntax( IdentifierTypeSyntax(name: .identifier("Any"), trailingTrivia: .space) )) } }
228. class Preprocessor: SyntaxRewriter { private var diagnostics: [Diagnostic] = [] static func process(_ syntax: inout SourceFileSyntax) -> [Diagnostic] { let processor = Preprocessor() syntax = processor.visit(syntax) return processor.diagnostics } override func visit(_ node: TypeAnnotationSyntax) -> TypeAnnotationSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: ReturnClauseSyntax) -> ReturnClauseSyntax { diagnostics.append(node.error("unsupported syntax '\(node.trimmed)'")) return node } override func visit(_ node: FunctionParameterSyntax) -> FunctionParameterSyntax { if node.colon.presence == .present { diagnostics.append(node.error("unsupported syntax ': \(node.type.trimmed)'")) } return node .with(\.colon.presence, .present) .with(\.type, TypeSyntax( IdentifierTypeSyntax(name: .identifier("Any"), trailingTrivia: .space) )) } }
229. print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = Preprocessor.diagnostics(for: sourceSyntax) diagnostics += ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) diagnostics += interpreter.diagnostics interpreter.diagnostics.removeAll() for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } if result != .undefined { print("= \(result)") } }
230. print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } let sourceSyntax = Parser.parse(source: input) var diagnostics = Preprocessor.diagnostics(for: sourceSyntax) diagnostics += ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) diagnostics += interpreter.diagnostics interpreter.diagnostics.removeAll() for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } if result != .undefined { print("= \(result)") } }
231. print("Type expressions to see the result. Type 'exit' to quit.") let interpreter = Interpreter(viewMode: .fixedUp) while true { print("> ", terminator: "") guard let input = readLine(), input.lowercased() != "exit" else { break } var sourceSyntax = Parser.parse(source: input) var diagnostics = Preprocessor.process(&sourceSyntax) diagnostics += ParseDiagnosticsGenerator.diagnostics(for: sourceSyntax) let operatorTable = OperatorTable.standardOperators let foldedSyntax = operatorTable.foldAll(sourceSyntax) { error in diagnostics.append(error.asDiagnostic) } let result = interpreter.evaluate(foldedSyntax) diagnostics += interpreter.diagnostics interpreter.diagnostics.removeAll() for diagnostic in diagnostics { print(diagnostic) } if diagnostics.contains(where: { $0.diagMessage.severity == .error }) { continue } if result != .undefined { print("= \(result)") } }
243. SWIFT EVAL
244. SWIFT EVAL
245. STRONG EVAL
246. STATIC EVAL
247. FAST EVAL
248. SWIFT SYNTAX
250. EVAL EVIL
251. SWIFTSYNTAX FOR GOOD AND EVIL
252. THANK YOU HTTPS://GITHUB.COM/NICKLOCKWOOD/SWIFTSYNTAXTALK