firefly-compiler 0.4.4

package/compiler/Patterns.ff

@@ -0,0 +1,111 @@
+import Syntax
+
+data PatternInfo(
+    variant: String
+    otherVariants: Set[String]
+    fields: List[Pair[String, PatternInfo]]
+)
+
+data PatternCaseInfo(
+    fields: List[Pair[String, PatternInfo]]
+    guard: Bool
+)
+
+check(
+    variants: Map[String, Set[String]]
+    fields: List[Pair[String, PatternInfo]]
+    cases: List[PatternCaseInfo]
+    success: Bool
+    guard: Bool
+): Unit {
+    Pair(fields, cases).{
+        | Pair([Pair(f, PatternInfo p), ...fs], cs) =>
+            let vs = variants.get(f).else {p.otherVariants.add(p.variant)}
+            if(vs.contains(p.variant)) {
+                let newFields = p.fields.map {_.mapFirst {f + "." + p.variant + "_" + _}}
+                if(vs.size() == 1) {
+                    check(variants.add(f, vs), [...newFields, ...fs], cs, True, guard)
+                } else {
+                    check(variants.add(f, [p.variant].toSet()), [...newFields, ...fs], cs, True, guard)
+                    check(variants.add(f, vs.remove(p.variant)), [], cs, False, guard)
+                }
+            } else {
+                check(variants, [], cs, False, guard)
+            }
+        | _ {success && !guard} =>
+        | Pair([], [PatternCaseInfo(fs, g), ...cs]) =>
+            check(variants, fs, cs, True, g)
+        | Pair([], []) =>
+            let remaining = variants.pairs().filter {_.second.size() != 0}.map {| Pair(f, vs) =>
+                f + " could be " + Show.show(vs.toList())
+            }
+            if(remaining.size() != 0) {
+                panic("Unexhaustive match:\n" + remaining.join("\n"))
+            }
+    }
+}
+
+convert(modules: Map[String, Module], cases: List[MatchCase]): List[PatternCaseInfo] {
+    function unqualifiedName(name: String): String {
+        name.reverse().takeWhile {_ != '.'}.reverse()
+    }
+    function otherVariants(name: String): Set[String] {
+        let variantName = unqualifiedName(name)
+        let moduleName = name.dropLast(variantName.size() + 1)
+        let variantModule = modules.grab(moduleName)
+        variantModule.types.collectFirst {definition =>
+            definition.variants.find {_.name == variantName}.map {variant =>
+                definition.variants.map {_.name}.filter {_ != variantName}.toSet()
+            }
+        }.grab()
+    }
+    function convertPattern(pattern: MatchPattern): Option[PatternInfo] {
+        | PString _ =>
+            Some(PatternInfo("String literal", ["Any other String literal"].toSet(), []))
+        | PInt _ =>
+            Some(PatternInfo("Int literal", ["Any other Int literal"].toSet(), []))
+        | PChar _ =>
+            Some(PatternInfo("Char literal", ["Any other Char literal"].toSet(), []))
+        | PVariable p =>
+            None
+        | PVariant p =>
+            let fields = p.patterns.map(convertPattern).pairs().collect {
+                | Pair(i, Some(p)) => Some(Pair("" + i, p))
+                | _ => None
+            }
+            Some(PatternInfo(unqualifiedName(p.name), otherVariants(p.name), fields))
+        | PVariantAs p =>
+            Some(PatternInfo(unqualifiedName(p.name), otherVariants(p.name), []))
+        | PAlias p =>
+            convertPattern(p.pattern)
+    }
+    cases.pairs().map {| Pair(caseIndex, case) =>
+        let fields = case.patterns.map(convertPattern).pairs().collect {
+            | Pair(i, Some(p)) => Some(Pair("" + i, p))
+            | _ => None
+        }
+        let exhaustiveGuards = case.guards.all {g =>
+            let guardConverted = convert(modules, [MatchCase(g.at, [g.pattern], [], case.body)])
+            try {
+                check([].toMap(), [], guardConverted, False, False)
+                True
+            } else {
+                False
+            }
+        }
+        PatternCaseInfo(fields, !exhaustiveGuards)
+    }
+}
+
+convertAndCheck(modules: Map[String, Module], cases: List[MatchCase]): Unit {
+    let converted = convert(modules, cases)
+    try {
+        check([].toMap(), [], converted, False, False)
+    } else {
+        throw(CompileError(cases.grab(0).at, "Unexhaustive match"))
+    }
+}
+
+fail[T](at: Location, message: String): T {
+    panic(message + " " + at.show())
+}