parse modules, other parser improvements (#29)

Parse plus basic constraints.

Author: maxdeliso

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "deno.enable": true,
+  "debug.javascript.autoAttachFilter": "onlyWithFlag",
+  "deno.codeLens.test": true
+}

deno.lock

@@ -55,8 +55,14 @@ export {
   type TypeDefinition,
 } from "./meta/trip.ts";
 export { externalReferences } from "./meta/frontend/externalReferences.ts";
-export { indexSymbols, resolveDefTerm } from "./meta/frontend/symbolTable.ts";
-export { resolveRefs } from "./meta/frontend/substitution.ts";
+export {
+  extractDefinitionValue,
+  indexSymbols,
+} from "./meta/frontend/symbolTable.ts";
+export {
+  resolveExternalProgramReferences,
+  resolveExternalTermReferences,
+} from "./meta/frontend/substitution.ts";
 
 // Additional utility exports
 export { UnChurchNumber } from "./ski/church.ts";

lib/index.ts

@@ -1,16 +1,22 @@
-import type { SymbolTable, TripLangProgram, TripLangTerm } from "../trip.ts";
+import type {
+  SymbolTable,
+  TripLangProgram,
+  TripLangTerm,
+  TripLangValueType,
+} from "../trip.ts";
 import {
+  extractDefinitionValue,
   indexSymbols as indexSymbolsImpl,
-  resolveDefTerm,
 } from "./symbolTable.ts";
 import { elaborateTerms } from "./elaboration.ts";
-import { resolveRefs } from "./substitution.ts";
+import { resolveExternalProgramReferences } from "./substitution.ts";
 import { externalReferences } from "./externalReferences.ts";
 import {
   type AVLTree,
   createEmptyAVL,
-  emptyAVL,
   insertAVL,
+  keyValuePairs,
+  searchAVL,
 } from "../../data/avl/avlNode.ts";
 import { parseTripLang } from "../../parser/tripLang.ts";
 import { typecheckSystemF } from "../../index.ts";
@@ -104,6 +110,27 @@ export interface TypecheckedProgramWithTypes {
 
 export function parse(input: string): ParsedProgram {
   const program = parseTripLang(input);
+
+  // Validate module constraints
+  const moduleDefinitions = program.terms.filter((term) =>
+    term.kind === "module"
+  );
+
+  if (moduleDefinitions.length === 0) {
+    throw new CompilationError(
+      "No module definition found. Each program must have exactly one module definition.",
+      "parse",
+    );
+  }
+
+  if (moduleDefinitions.length > 1) {
+    const moduleNames = moduleDefinitions.map((m) => m.name).join(", ");
+    throw new CompilationError(
+      `Multiple module definitions found: ${moduleNames}. Each program must have exactly one module definition.`,
+      "parse",
+    );
+  }
+
   return { ...program, __moniker: Symbol() } as ParsedProgram;
 }
 
@@ -137,19 +164,77 @@ export function elaborate(
 export function resolve(
   programWithSymbols: ElaboratedProgramWithSymbols,
 ): ResolvedProgram {
-  const resolved = resolveRefs(
+  // Collect imported symbol names
+  const importedSymbols = new Set<string>();
+  for (const term of programWithSymbols.program.terms) {
+    if (term.kind === "import") {
+      importedSymbols.add(term.name);
+    }
+  }
+
+  const resolved = resolveExternalProgramReferences(
     programWithSymbols.program,
     programWithSymbols.symbols,
   );
 
   for (const resolvedTerm of resolved.terms) {
-    const defTerm = resolveDefTerm(resolvedTerm);
-    const [ut, uty] = externalReferences(defTerm);
-    if (!emptyAVL(ut) || !emptyAVL(uty)) {
+    const definitionValue = extractDefinitionValue(resolvedTerm);
+    if (definitionValue === undefined) {
+      continue;
+    }
+    const [ut, uty] = externalReferences(definitionValue);
+
+    // Check for unresolved terms that are not imported
+    const unresolvedTerms = keyValuePairs(ut).map((kvp) => kvp[0]);
+    const unresolvedTypes = keyValuePairs(uty).map((kvp) => kvp[0]);
+
+    const nonImportedUnresolvedTerms = unresolvedTerms.filter((term) =>
+      !importedSymbols.has(term)
+    );
+    const nonImportedUnresolvedTypes = unresolvedTypes.filter((type) =>
+      !importedSymbols.has(type)
+    );
+
+    if (
+      nonImportedUnresolvedTerms.length > 0 ||
+      nonImportedUnresolvedTypes.length > 0
+    ) {
+      // Create filtered AVL trees with only non-imported unresolved references
+      let filteredTerms = createEmptyAVL<string, TripLangValueType>();
+      let filteredTypes = createEmptyAVL<string, BaseType>();
+
+      for (const term of nonImportedUnresolvedTerms) {
+        const termValue = searchAVL(ut, term, compareStrings);
+        if (termValue) {
+          filteredTerms = insertAVL(
+            filteredTerms,
+            term,
+            termValue,
+            compareStrings,
+          );
+        }
+      }
+
+      for (const type of nonImportedUnresolvedTypes) {
+        const typeValue = searchAVL(uty, type, compareStrings);
+        if (typeValue) {
+          filteredTypes = insertAVL(
+            filteredTypes,
+            type,
+            typeValue,
+            compareStrings,
+          );
+        }
+      }
+
       throw new CompilationError(
         "Unresolved external references after resolution",
         "resolve",
-        { term: resolvedTerm, unresolvedTerms: ut, unresolvedTypes: uty },
+        {
+          term: resolvedTerm,
+          unresolvedTerms: filteredTerms,
+          unresolvedTypes: filteredTypes,
+        },
       );
     }
   }
@@ -160,10 +245,37 @@ export function resolve(
 export function typecheck(
   program: ResolvedProgram,
 ): TypecheckedProgramWithTypes {
+  // Collect imported symbol names
+  const importedSymbols = new Set<string>();
+  for (const term of program.terms) {
+    if (term.kind === "import") {
+      importedSymbols.add(term.name);
+    }
+  }
+
   let types = createEmptyAVL<string, BaseType>();
 
   for (const term of program.terms) {
     try {
+      // Check if the term contains unresolved imported symbols
+      const definitionValue = extractDefinitionValue(term);
+      if (definitionValue !== undefined) {
+        const [ut, uty] = externalReferences(definitionValue);
+        const unresolvedTerms = keyValuePairs(ut).map((kvp) => kvp[0]);
+        const unresolvedTypes = keyValuePairs(uty).map((kvp) => kvp[0]);
+
+        // Check if any unresolved references are imported symbols
+        const hasUnresolvedImportedSymbols = unresolvedTerms.some((term) =>
+          importedSymbols.has(term)
+        ) ||
+          unresolvedTypes.some((type) => importedSymbols.has(type));
+
+        if (hasUnresolvedImportedSymbols) {
+          // Skip typechecking for terms with unresolved imported symbols
+          continue;
+        }
+      }
+
       switch (term.kind) {
         case "poly":
           types = insertAVL(

lib/meta/frontend/compilation.ts

@@ -38,6 +38,12 @@ export function elaborateTerm(
       return term;
     case "type":
       return term;
+    case "module":
+      return term;
+    case "import":
+      return term;
+    case "export":
+      return term;
   }
 }
 

lib/meta/frontend/elaboration.ts

@@ -6,17 +6,17 @@ import {
 } from "../../data/avl/avlNode.ts";
 import { compareStrings } from "../../data/map/stringMap.ts";
 import type { BaseType } from "../../types/types.ts";
-import type { TripLangDefType } from "../trip.ts";
+import type { TripLangValueType } from "../trip.ts";
 import { CompilationError } from "./compilation.ts";
 
-export function externalReferences(td: TripLangDefType): [
-  AVLTree<string, TripLangDefType>,
+export function externalReferences(td: TripLangValueType): [
+  AVLTree<string, TripLangValueType>,
   AVLTree<string, BaseType>,
 ] {
-  let externalTermRefs = createEmptyAVL<string, TripLangDefType>();
+  let externalTermRefs = createEmptyAVL<string, TripLangValueType>();
   let externalTypeRefs = createEmptyAVL<string, BaseType>();
-  let absBindMap = createEmptyAVL<string, TripLangDefType>();
-  const defStack: TripLangDefType[] = [td];
+  let absBindMap = createEmptyAVL<string, TripLangValueType>();
+  const defStack: TripLangValueType[] = [td];
 
   while (defStack.length) {
     const current = defStack.pop();

lib/meta/frontend/externalReferences.ts

@@ -19,5 +19,11 @@ export function prettyTerm(dt: TripLangTerm): string {
       return dt.name + def + prettyPrintSKI(dt.term);
     case "type":
       return dt.name + def + prettyPrintTy(dt.type);
+    case "module":
+      return `module ${dt.name}`;
+    case "import":
+      return `import ${dt.name} from ${dt.ref}`;
+    case "export":
+      return `export ${dt.name}`;
   }
 }