fix eval function name collision bugs by adding a pattern id. The id …

…is used in the eval function name before the type because types could end in a number, casusing posible name collisions.
amnykon · Sep 9, 2017 · 0b79b4f · 0b79b4f
1 parent 84d0d3c
commit 0b79b4f
Show file tree

Hide file tree

Showing 3 changed files with 46 additions and 48 deletions.
diff --git a/Sources/SParserPrivate/Pattern.swift b/Sources/SParserPrivate/Pattern.swift
@@ -3,6 +3,7 @@ import Foundation
 public struct Pattern {
   public let terms: [Term]
   public let evaluator: String
+  public let id: Int
 
   func buildEvaluatorString(ruleName: String) -> String {
     let termsString = terms.flatMap{
@@ -15,7 +16,7 @@ public struct Pattern {
       }
     }.joined(separator: ", ")
     return 
-      "fileprivate func eval\(ruleName.capitalizedFirstLetter())(\(termsString)) -> Parser.\(ruleName.capitalizedFirstLetter())Type {\n" +
+      "fileprivate func eval\(id)\(ruleName.capitalizedFirstLetter())(\(termsString)) -> Parser.\(ruleName.capitalizedFirstLetter())Type {\n" +
       "  \(evaluator)\n" +
       "}\n"
   }
@@ -30,7 +31,7 @@ public struct Pattern {
         return "\(name): \(name)"
       }
     }.joined(separator: ", ")
-    return "return try recursivelyRead(\(ruleName): eval\(ruleName.capitalizedFirstLetter())(\(termsString)))\n"
+    return "return try recursivelyRead(\(ruleName): eval\(id)\(ruleName.capitalizedFirstLetter())(\(termsString)))\n"
   }
 }
 
diff --git a/Sources/SParserPrivate/SParser.sparser b/Sources/SParserPrivate/SParser.sparser
@@ -45,15 +45,15 @@ type
 patterns
   type
     [Pattern]
-  ::= pattern patterns
-    return [pattern] + patterns
+  ::= patterns pattern
+    return patterns + [Pattern(terms: pattern.terms, evaluator: pattern.evaluator, id: patterns.count)]
   ::=
     return []
 pattern
   type
     Pattern
   ::= "::=" cws terms "\n" multiLineString
-    return Pattern(terms: terms, evaluator: multiLineString)
+    return Pattern(terms: terms, evaluator: multiLineString, id: 0)
 terms
   type
     [Term]

diff --git a/Sources/SParserPrivate/SParser.sparser.swift b/Sources/SParserPrivate/SParser.sparser.swift
@@ -1,10 +1,10 @@
 import Foundation
 import SParserLibs
-fileprivate func evalSyntax(importRule: Parser.ImportRuleType, rules: Parser.RulesType) -> Parser.SyntaxType {
+fileprivate func eval0Syntax(importRule: Parser.ImportRuleType, rules: Parser.RulesType) -> Parser.SyntaxType {
   return Syntax(imports: importRule, rules: rules)
 }
 
-fileprivate func evalSyntax(rules: Parser.RulesType) -> Parser.SyntaxType {
+fileprivate func eval1Syntax(rules: Parser.RulesType) -> Parser.SyntaxType {
   return Syntax(imports: [], rules: rules)
 }
 
@@ -16,18 +16,18 @@ extension Parser {
   public func readSyntax() throws -> SyntaxType? {
     if let importRule = try readImportRule() {
       if let rules = try readRules() {
-        return try recursivelyRead(syntax: evalSyntax(importRule: importRule, rules: rules))
+        return try recursivelyRead(syntax: eval0Syntax(importRule: importRule, rules: rules))
       }
       try throwError(message:"error parsing syntax. expect rules")
     }
     if let rules = try readRules() {
-      return try recursivelyRead(syntax: evalSyntax(rules: rules))
+      return try recursivelyRead(syntax: eval1Syntax(rules: rules))
     }
     return nil
   }
 }
 
-fileprivate func evalImportRule(indent: Parser.IndentType, imports: Parser.ImportsType, dedent: Parser.DedentType) -> Parser.ImportRuleType {
+fileprivate func eval0ImportRule(indent: Parser.IndentType, imports: Parser.ImportsType, dedent: Parser.DedentType) -> Parser.ImportRuleType {
   return imports
 }
 
@@ -41,7 +41,7 @@ extension Parser {
       if let indent = try readIndent() {
         if let imports = try readImports() {
           if let dedent = try readDedent() {
-            return try recursivelyRead(importRule: evalImportRule(indent: indent, imports: imports, dedent: dedent))
+            return try recursivelyRead(importRule: eval0ImportRule(indent: indent, imports: imports, dedent: dedent))
           }
           try throwError(message:"error parsing importRule. expect dedent")
         }
@@ -53,11 +53,11 @@ extension Parser {
   }
 }
 
-fileprivate func evalImports(importFramework: Parser.ImportFrameworkType, imports: Parser.ImportsType) -> Parser.ImportsType {
+fileprivate func eval0Imports(importFramework: Parser.ImportFrameworkType, imports: Parser.ImportsType) -> Parser.ImportsType {
   return [importFramework] + imports
 }
 
-fileprivate func evalImports() -> Parser.ImportsType {
+fileprivate func eval1Imports() -> Parser.ImportsType {
   return []
 }
 
@@ -69,15 +69,15 @@ extension Parser {
   public func readImports() throws -> ImportsType? {
     if let importFramework = try readImportFramework() {
       if let imports = try readImports() {
-        return try recursivelyRead(imports: evalImports(importFramework: importFramework, imports: imports))
+        return try recursivelyRead(imports: eval0Imports(importFramework: importFramework, imports: imports))
       }
       try throwError(message:"error parsing imports. expect imports")
     }
-    return try recursivelyRead(imports: evalImports())
+    return try recursivelyRead(imports: eval1Imports())
   }
 }
 
-fileprivate func evalImportFramework(line: Parser.LineType) -> Parser.ImportFrameworkType {
+fileprivate func eval0ImportFramework(line: Parser.LineType) -> Parser.ImportFrameworkType {
   return line
 }
 
@@ -88,34 +88,34 @@ extension Parser {
   }
   public func readImportFramework() throws -> ImportFrameworkType? {
     if let line = try readLine() {
-      return try recursivelyRead(importFramework: evalImportFramework(line: line))
+      return try recursivelyRead(importFramework: eval0ImportFramework(line: line))
     }
     return nil
   }
 }
 
-fileprivate func evalRules(rules: Parser.RulesType, rule: Parser.RuleType) -> Parser.RulesType {
+fileprivate func eval0Rules(rules: Parser.RulesType, rule: Parser.RuleType) -> Parser.RulesType {
   return rules + [rule]
 }
 
-fileprivate func evalRules() -> Parser.RulesType {
+fileprivate func eval1Rules() -> Parser.RulesType {
   return []
 }
 
 extension Parser {
   public typealias RulesType = [Rule]
   private func recursivelyRead(rules: RulesType) throws -> RulesType? {
     if let rule = try readRule() {
-      return try recursivelyRead(rules: evalRules(rules: rules, rule: rule))
+      return try recursivelyRead(rules: eval0Rules(rules: rules, rule: rule))
     }
     return rules
   }
   public func readRules() throws -> RulesType? {
-    return try recursivelyRead(rules: evalRules())
+    return try recursivelyRead(rules: eval1Rules())
   }
 }
 
-fileprivate func evalRule(name: Parser.NameType, indent: Parser.IndentType, type: Parser.TypeType, patterns: Parser.PatternsType, dedent: Parser.DedentType) -> Parser.RuleType {
+fileprivate func eval0Rule(name: Parser.NameType, indent: Parser.IndentType, type: Parser.TypeType, patterns: Parser.PatternsType, dedent: Parser.DedentType) -> Parser.RuleType {
   return Rule(name: name, type: type, patterns: patterns)
 }
 
@@ -131,7 +131,7 @@ extension Parser {
           if let type = try readType() {
             if let patterns = try readPatterns() {
               if let dedent = try readDedent() {
-                return try recursivelyRead(rule: evalRule(name: name, indent: indent, type: type, patterns: patterns, dedent: dedent))
+                return try recursivelyRead(rule: eval0Rule(name: name, indent: indent, type: type, patterns: patterns, dedent: dedent))
               }
               try throwError(message:"error parsing rule. expect dedent")
             }
@@ -147,7 +147,7 @@ extension Parser {
   }
 }
 
-fileprivate func evalType(indent: Parser.IndentType, line: Parser.LineType, dedent: Parser.DedentType) -> Parser.TypeType {
+fileprivate func eval0Type(indent: Parser.IndentType, line: Parser.LineType, dedent: Parser.DedentType) -> Parser.TypeType {
   return line
 }
 
@@ -161,7 +161,7 @@ extension Parser {
       if let indent = try readIndent() {
         if let line = try readLine() {
           if let dedent = try readDedent() {
-            return try recursivelyRead(type: evalType(indent: indent, line: line, dedent: dedent))
+            return try recursivelyRead(type: eval0Type(indent: indent, line: line, dedent: dedent))
           }
           try throwError(message:"error parsing type. expect dedent")
         }
@@ -173,32 +173,29 @@ extension Parser {
   }
 }
 
-fileprivate func evalPatterns(pattern: Parser.PatternType, patterns: Parser.PatternsType) -> Parser.PatternsType {
-  return [pattern] + patterns
+fileprivate func eval0Patterns(patterns: Parser.PatternsType, pattern: Parser.PatternType) -> Parser.PatternsType {
+  return patterns + [Pattern(terms: pattern.terms, evaluator: pattern.evaluator, id: patterns.count)]
 }
 
-fileprivate func evalPatterns() -> Parser.PatternsType {
+fileprivate func eval1Patterns() -> Parser.PatternsType {
   return []
 }
 
 extension Parser {
   public typealias PatternsType = [Pattern]
   private func recursivelyRead(patterns: PatternsType) throws -> PatternsType? {
+    if let pattern = try readPattern() {
+      return try recursivelyRead(patterns: eval0Patterns(patterns: patterns, pattern: pattern))
+    }
     return patterns
   }
   public func readPatterns() throws -> PatternsType? {
-    if let pattern = try readPattern() {
-      if let patterns = try readPatterns() {
-        return try recursivelyRead(patterns: evalPatterns(pattern: pattern, patterns: patterns))
-      }
-      try throwError(message:"error parsing patterns. expect patterns")
-    }
-    return try recursivelyRead(patterns: evalPatterns())
+    return try recursivelyRead(patterns: eval1Patterns())
   }
 }
 
-fileprivate func evalPattern(cws: Parser.CwsType, terms: Parser.TermsType, multiLineString: Parser.MultiLineStringType) -> Parser.PatternType {
-  return Pattern(terms: terms, evaluator: multiLineString)
+fileprivate func eval0Pattern(cws: Parser.CwsType, terms: Parser.TermsType, multiLineString: Parser.MultiLineStringType) -> Parser.PatternType {
+  return Pattern(terms: terms, evaluator: multiLineString, id: 0)
 }
 
 extension Parser {
@@ -212,7 +209,7 @@ extension Parser {
         if let terms = try readTerms() {
           if matches(string: "\n") {
             if let multiLineString = try readMultiLineString() {
-              return try recursivelyRead(pattern: evalPattern(cws: cws, terms: terms, multiLineString: multiLineString))
+              return try recursivelyRead(pattern: eval0Pattern(cws: cws, terms: terms, multiLineString: multiLineString))
             }
             try throwError(message:"error parsing pattern. expect multiLineString")
           }
@@ -226,11 +223,11 @@ extension Parser {
   }
 }
 
-fileprivate func evalTerms(term: Parser.TermType, cws: Parser.CwsType, terms: Parser.TermsType) -> Parser.TermsType {
+fileprivate func eval0Terms(term: Parser.TermType, cws: Parser.CwsType, terms: Parser.TermsType) -> Parser.TermsType {
   return [term] + terms
 }
 
-fileprivate func evalTerms() -> Parser.TermsType {
+fileprivate func eval1Terms() -> Parser.TermsType {
   return []
 }
 
@@ -243,21 +240,21 @@ extension Parser {
     if let term = try readTerm() {
       if let cws = try readCws() {
         if let terms = try readTerms() {
-          return try recursivelyRead(terms: evalTerms(term: term, cws: cws, terms: terms))
+          return try recursivelyRead(terms: eval0Terms(term: term, cws: cws, terms: terms))
         }
         try throwError(message:"error parsing terms. expect terms")
       }
       try throwError(message:"error parsing terms. expect cws")
     }
-    return try recursivelyRead(terms: evalTerms())
+    return try recursivelyRead(terms: eval1Terms())
   }
 }
 
-fileprivate func evalTerm(name: Parser.NameType) -> Parser.TermType {
+fileprivate func eval0Term(name: Parser.NameType) -> Parser.TermType {
   return .named(name)
 }
 
-fileprivate func evalTerm(quotedString: Parser.QuotedStringType) -> Parser.TermType {
+fileprivate func eval1Term(quotedString: Parser.QuotedStringType) -> Parser.TermType {
   return .quoted(quotedString)
 }
 
@@ -268,16 +265,16 @@ extension Parser {
   }
   public func readTerm() throws -> TermType? {
     if let name = try readName() {
-      return try recursivelyRead(term: evalTerm(name: name))
+      return try recursivelyRead(term: eval0Term(name: name))
     }
     if let quotedString = try readQuotedString() {
-      return try recursivelyRead(term: evalTerm(quotedString: quotedString))
+      return try recursivelyRead(term: eval1Term(quotedString: quotedString))
     }
     return nil
   }
 }
 
-fileprivate func evalName(letter: Parser.LetterType, letterDigits: Parser.LetterDigitsType) -> Parser.NameType {
+fileprivate func eval0Name(letter: Parser.LetterType, letterDigits: Parser.LetterDigitsType) -> Parser.NameType {
   return String(letter) + letterDigits
 
 }
@@ -290,7 +287,7 @@ extension Parser {
   public func readName() throws -> NameType? {
     if let letter = try readLetter() {
       if let letterDigits = try readLetterDigits() {
-        return try recursivelyRead(name: evalName(letter: letter, letterDigits: letterDigits))
+        return try recursivelyRead(name: eval0Name(letter: letter, letterDigits: letterDigits))
       }
       try throwError(message:"error parsing name. expect letterDigits")
     }