slow.monster

STUDIO HAZE · topaz

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.20 · 56 files

compiler/crates/topaz_self_frontend/topaz/resolver.tpz

Topaz · 3721 B · Original file

1// Resolution entry point for the embedded self compiler.
2// Graph discovery and scope walking are delegated to resolver leaves; this file
3// admits host facts and assembles the public resolved preview.
5import types {
6 PreviewGeneratedStdModule,
7 PreviewHostFact,
8 PreviewHostQuery,
9 PreviewResolvedDiagnostic,
10 ResolveResult,
12import resolver.graph {
13 dependencyOrder,
14 diagnoseCycles,
15 discoverModuleGraph,
16 moduleDependencyCatalog,
17 moduleIdentity,
18 parseModule,
19 pendingResult,
20 readEntrySource,
21 validateEntryPath,
22 validateEntryPhysicalContainment,
24import resolver.model_facts {
25 ResolverInputs,
26 ResolverHostFactCatalog,
27 addQuery,
28 resolverHostFacts,
30import resolver.modules_tables { buildModuleTables }
31import resolver.validation_init {
32 rejectedResult,
33 resolvedResult,
34 validateImportSurfaces,
37// Resolves an entry module from explicit host facts without performing I/O.
38export function resolvePreview(
39 entry: string,
40 root: string,
41 facts: Array<PreviewHostFact>,
42 externModules: Array<string>,
43 generatedStdModules: Array<PreviewGeneratedStdModule>,
44 maxAstNodes: int,
45 maxAstDepth: int,
46) -> Result<ResolveResult, string> {
47 resolveWithFacts(entry, root, resolverHostFacts(facts), externModules,
48 generatedStdModules, maxAstNodes, maxAstDepth)
51// The catalog and its callback belong to this invocation. Graph discovery
52// continues at each fact request without restarting parsing or resolution.
53export function resolveWithFacts(
54 entry: string,
55 root: string,
56 hostFacts: ResolverHostFactCatalog,
57 externModules: Array<string>,
58 generatedStdModules: Array<PreviewGeneratedStdModule>,
59 maxAstNodes: int,
60 maxAstDepth: int,
61) -> Result<ResolveResult, string> {
62 let mut diagnostics: Array<PreviewResolvedDiagnostic> = []
63 if !validateEntryPath(entry, root, diagnostics) {
64 return Ok(rejectedResult([], [], diagnostics))
65 }
66 let inputs = ResolverInputs {
67 root: root,
68 hostFacts: hostFacts,
69 externModules: externModules,
70 generatedStdModules: generatedStdModules,
71 maxAstNodes: maxAstNodes,
72 maxAstDepth: maxAstDepth,
73 }
74 let mut queries: Array<PreviewHostQuery> = []
75 addQuery(queries, inputs.hostFacts, "physical-containment", entry)
76 addQuery(queries, inputs.hostFacts, "read-source", entry)
77 if hostFacts.errors.length > 0 { return Err(hostFacts.errors[0]) }
78 if queries.length > 0 {
79 return Ok(pendingResult(queries))
80 }
81 if !validateEntryPhysicalContainment(entry, inputs.hostFacts, diagnostics) {
82 return Ok(rejectedResult([], [], diagnostics))
83 }
84 let entrySource = match readEntrySource(entry, inputs.hostFacts, diagnostics) {
85 case Some(source) => source
86 case None => return Ok(rejectedResult([], [], diagnostics))
87 }
89 let entryDraft = parseModule(
90 0,
91 moduleIdentity(entry, root),
92 entry,
93 entrySource,
94 true,
95 false,
96 false,
97 maxAstNodes,
98 maxAstDepth,
99 )?
100 let graph = discoverModuleGraph(entryDraft, inputs, queries, diagnostics)?
101 if hostFacts.errors.length > 0 { return Err(hostFacts.errors[0]) }
102 if queries.length > 0 {
103 return Ok(pendingResult(queries))
104 }
106 let discovered = graph.modules
107 let edges = graph.edges
108 let dependencies = moduleDependencyCatalog(discovered, edges)
109 diagnoseCycles(dependencies, edges, diagnostics)
110 let ordered = if diagnostics.length == 0 {
111 dependencyOrder(discovered, dependencies)
112 } else {
113 discovered
114 }
115 if diagnostics.length > 0 {
116 return Ok(rejectedResult(ordered, dependencies.publicEdges, diagnostics))
117 }
118 let tables = buildModuleTables(ordered, diagnostics)
119 validateImportSurfaces(ordered, tables, diagnostics)
120 resolvedResult(ordered, dependencies.publicEdges, tables, diagnostics)

SHA256 c1517f702458f6bfe55e639b0bf081e64f088d056aa22eab0511f89c5c7e4e54