🚧 working semantic analyzer with nested scopes (breaking the interpreter)

Author: igorkulman

PascalInterpreter/PascalInterpreter/Semantic analyzer/SemanticAnalyzer.swift

@@ -9,15 +9,15 @@
 import Foundation
 
 public class SemanticAnalyzer {
-    private let symbolTable = ScopedSymbolTable(name: "global", level: 1)
+    private var currentScope: ScopedSymbolTable?
 
     public init() {
 
     }
 
     public func build(node: AST) -> ScopedSymbolTable {
         visit(node: node)
-        return symbolTable
+        return ScopedSymbolTable(name: "global", level: 1, enclosingScope: nil)
     }
 
     private func visit(node: AST) {
@@ -28,7 +28,11 @@ public class SemanticAnalyzer {
             }
             visit(node: compoundStatement)
         case let .program(name: _, block: block):
+            let globalScope = ScopedSymbolTable(name: "global", level: 1, enclosingScope: nil)
+            currentScope = globalScope
             visit(node: block)
+            print(globalScope)
+            currentScope = nil
         case let .binaryOperation(left: left, operation: _, right: right):
             visit(node: left)
             visit(node: right)
@@ -43,41 +47,57 @@ public class SemanticAnalyzer {
         case .noOp:
             break
         case let .variable(name):
-            guard symbolTable.lookup(name) != nil else {
+            guard let scope = currentScope else {
+                fatalError("Cannot access a variable outside a scope")
+            }
+            guard scope.lookup(name) != nil else {
                 fatalError("Symbol(indetifier) not found '\(name)'")
             }
         case let .variableDeclaration(name: variable, type: variableType):
+            guard let scope = currentScope else {
+                fatalError("Cannot declare a variable outside a scope")
+            }
+
             guard case let .variable(name) = variable, case let .type(type) = variableType else {
                 fatalError("Invalid variable \(variable) or invalid type \(variableType)")
             }
 
-            guard symbolTable.lookup(name) == nil else {
+            guard scope.lookup(name, currentScopeOnly: true) == nil else {
                 fatalError("Duplicate identifier '\(name)' found")
             }
 
-            guard let symbolType = symbolTable.lookup(type.description) else {
+            guard let symbolType = scope.lookup(type.description) else {
                 fatalError("Type not found '\(type.description)'")
             }
 
-            symbolTable.insert(.variable(name: name, type: symbolType))
+            scope.insert(.variable(name: name, type: symbolType))
         case let .assignment(left: left, right: right):
             visit(node: right)
             visit(node: left)
         case .type:
             break
-        case let .procedure(name: name, params: params, block: _):
+        case let .procedure(name: name, params: params, block: block):
+            let scope = ScopedSymbolTable(name: name, level: (currentScope?.level ?? 0) + 1, enclosingScope: currentScope)
+            currentScope = scope
+
             var parameters: [Symbol] = []
             for param in params {
                 guard case let .param(name: name, type: .type(type)) = param else {
                     fatalError("Only built int type parameters supported in procedure, got \(param)")
                 }
-                guard let symbol = symbolTable.lookup(type.description) else {
+                guard let symbol = scope.lookup(type.description) else {
                     fatalError("Type not found '\(type.description)'")
                 }
-                parameters.append(.variable(name: name, type: symbol))
+                let variable = Symbol.variable(name: name, type: symbol)
+                parameters.append(variable)
+                scope.insert(variable)
             }
             let symbol = Symbol.procedure(name: name, params: parameters)
-            symbolTable.insert(symbol)
+            scope.insert(symbol)
+
+            visit(node: block)
+            print(scope)
+            currentScope = currentScope?.enclosingScope
         case .param:
             break
         }

PascalInterpreter/PascalInterpreter/Semantic analyzer/SymbolTable.swift

@@ -13,10 +13,12 @@ public class ScopedSymbolTable {
 
     let name: String
     let level: Int
+    let enclosingScope: ScopedSymbolTable?
 
-    init(name: String, level: Int) {
+    init(name: String, level: Int, enclosingScope: ScopedSymbolTable?) {
         self.name = name
         self.level = level
+        self.enclosingScope = enclosingScope
 
         insert(.builtIn(.integer))
         insert(.builtIn(.real))
@@ -26,8 +28,16 @@ public class ScopedSymbolTable {
         symbols[symbol.name] = symbol
     }
 
-    func lookup(_ name: String) -> Symbol? {
-        return symbols[name]
+    func lookup(_ name: String, currentScopeOnly: Bool = false) -> Symbol? {
+        if let symbol = symbols[name] {
+            return symbol
+        }
+
+        if currentScopeOnly {
+            return nil
+        }
+
+        return enclosingScope?.lookup(name)
     }
 }