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/types.tpz

Topaz · 6173 B · Original file

1export record PreviewToken derives JSON {

2 kind: string,

3 lo: int,

4 hi: int,

5 stream: string,

6 synthetic: bool,

7}

9export record PreviewDiagnostic derives JSON {

10 code: string,

11 message: string,

12 lo: int,

13 hi: int,

14 notes: Array<string>,

15}

17export record PreviewAstAttribute derives JSON {

18 name: string,

19 kind: string,

20 value: string,

21}

23export record PreviewAstNode derives JSON {

24 kind: string,

25 lo: int,

26 hi: int,

27 parent: int,

28 field: string,

29 index: int,

30 attributeNames: Array<string>,

31 attributeKinds: Array<string>,

32 attributeValues: Array<string>,

33}

35export record SyntaxNode {

36 kind: string,

37 lo: int,

38 hi: int,

39 field: string,

40 index: int,

41 attributes: Array<PreviewAstAttribute>,

42 children: Array<SyntaxNode>,

43}

45export record RawResult {

46 tokens: Array<PreviewToken>,

47 diagnostics: Array<PreviewDiagnostic>,

48}

50export record LayoutResult {

51 tokens: Array<PreviewToken>,

52 diagnostics: Array<PreviewDiagnostic>,

53}

55export record ParseResult {

56 root: SyntaxNode,

57 nodes: Array<PreviewAstNode>,

58 diagnostics: Array<PreviewDiagnostic>,

59}

61export record PreviewDirectoryEntry derives JSON {

62 name: string,

63 kind: string,

64}

66export record PreviewHostFact derives JSON {

67 kind: string,

68 mountId: string,

69 logicalPath: string,

70 status: string,

71 source: string,

72 entries: Array<PreviewDirectoryEntry>,

73 aliasClass: string,

74 reasonCode: string,

75}

77export record PreviewHostQuery derives JSON {

78 kind: string,

79 mountId: string,

80 logicalPath: string,

81}

83export record PreviewGeneratedStdModule derives JSON {

84 identity: string,

85 path: string,

86 source: string,

87}

89export record PreviewModuleResult derives JSON {

90 sourceOrdinal: int,

91 identity: string,

92 path: string,

93 source: string,

94 entry: bool,

95 extern: bool,

96 generatedStd: bool,

97 raw: Array<PreviewToken>,

98 layout: Array<PreviewToken>,

99 ast: Array<PreviewAstNode>,

100}

101

102export record PreviewImportEdge derives JSON {

103 from: string,

104 to: string,

105}

106

107export record PreviewResolvedScope derives JSON {

108 moduleIndex: int,

109 ordinal: int,

110 parentOrdinal: int,

111 kind: string,

112 lo: int,

113 hi: int,

114}

115

116export record PreviewResolvedDeclaration derives JSON {

117 moduleIndex: int,

118 scopeOrdinal: int,

119 name: string,

120 namespace: string,

121 declarationKind: string,

122 lo: int,

123 hi: int,

124 exported: bool,

125 targetModule: string,

126 targetName: string,

127}

128

129export record PreviewResolvedReference derives JSON {

130 moduleIndex: int,

131 scopeOrdinal: int,

132 name: string,

133 namespace: string,

134 role: string,

135 lo: int,

136 hi: int,

137 targetModuleIndex: int,

138 targetLo: int,

139 targetHi: int,

140 targetNamespace: string,

141 targetModule: string,

142 targetName: string,

143}

144

145export record PreviewResolvedExport derives JSON {

146 moduleIndex: int,

147 name: string,

148 namespace: string,

149 declarationLo: int,

150 declarationHi: int,

151}

152

153export record PreviewResolvedDiagnostic derives JSON {

154 moduleIndex: int,

155 code: string,

156 message: string,

157 lo: int,

158 hi: int,

159 notes: Array<string>,

160}

161

162export record ResolveResult {

163 queries: Array<PreviewHostQuery>,

164 modules: Array<PreviewModuleResult>,

165 edges: Array<PreviewImportEdge>,

166 scopes: Array<PreviewResolvedScope>,

167 declarations: Array<PreviewResolvedDeclaration>,

168 references: Array<PreviewResolvedReference>,

169 exports: Array<PreviewResolvedExport>,

170 diagnostics: Array<PreviewResolvedDiagnostic>,

171}

172

173// Private checker exchange. Types are a strict preorder tree so the public

174// record surface itself stays non-recursive and JSON-round-trippable.

175export record PreviewTypeAtom derives JSON {

176 parent: int,

177 field: string,

178 index: int,

179 edgeName: string,

180 kind: string,

181 name: string,

182 value: string,

183 identity: string,

184 origin: string,

185}

186

187export record PreviewTypedNode derives JSON {

188 moduleIndex: int,

189 nodeKind: string,

190 lo: int,

191 hi: int,

192 typeValue: Array<PreviewTypeAtom>,

193 ambient: bool,

194}

195

196export record PreviewCallArgument derives JSON {

197 bindingKind: string,

198 bindingName: string,

199 sourceIndex: Option<int>,

200 lo: int,

201 hi: int,

202}

203

204export record PreviewCallEvaluation derives JSON {

205 kind: string,

206 argumentIndex: int,

207}

208

209export record PreviewTypedCall derives JSON {

210 moduleIndex: int,

211 lo: int,

212 hi: int,

213 calleeLo: int,

214 calleeHi: int,

215 calleeType: Array<PreviewTypeAtom>,

216 resultType: Array<PreviewTypeAtom>,

217 targetIdentity: string,

218 ambient: bool,

219 calleeKind: string,

220 method: string,

221 methodClass: string,

222 optional: bool,

223 shadowFirst: bool,

224 stageMethod: string,

225 arguments: Array<PreviewCallArgument>,

226 evaluations: Array<PreviewCallEvaluation>,

227}

228

229export record PreviewTypedCapture derives JSON {

230 moduleIndex: int,

231 closureLo: int,

232 closureHi: int,

233 referenceLo: int,

234 referenceHi: int,

235 declarationLo: int,

236 declarationHi: int,

237 name: string,

238 typeValue: Array<PreviewTypeAtom>,

239 ambient: bool,

240}

241

242export record PreviewCheckLabel derives JSON {

243 moduleIndex: int,

244 lo: int,

245 hi: int,

246 message: string,

247}

248

249export record PreviewCheckDiagnostic derives JSON {

250 moduleIndex: int,

251 code: string,

252 message: string,

253 primaryMessage: string,

254 lo: int,

255 hi: int,

256 secondary: Array<PreviewCheckLabel>,

257 notes: Array<string>,

258 profileRule: string,

259}

260

261export record CheckResult {

262 nodes: Array<PreviewTypedNode>,

263 calls: Array<PreviewTypedCall>,

264 captures: Array<PreviewTypedCapture>,

265 diagnostics: Array<PreviewCheckDiagnostic>,

266}

267

268export record LowerBridgeRequest derives JSON {

269 producer: string,

270 producerStage: int,

271 frontEnd: string,

272 frontEndStatus: string,

273 modules: Array<PreviewModuleResult>,

274 references: Array<PreviewResolvedReference>,

275 typedNodes: Array<PreviewTypedNode>,

276 typedCalls: Array<PreviewTypedCall>,

277 typedCaptures: Array<PreviewTypedCapture>,

278 edges: Array<PreviewImportEdge>,

279 moduleDeclarations: Array<PreviewResolvedDeclaration>,

280 languageMode: string,

281 sourceSetId: string,

282 maxLoweredNodes: int,

283}

284

285export function encodeLowerBridgeRequest(

286 request: LowerBridgeRequest,

287) -> Result<Bytes, string> {

288 Ok(Bytes.encodeUtf8(JSON.stringify(request)?))

289}

290

291export function decodeLowerBridgeRequest(

292 text: string,

293) -> Result<LowerBridgeRequest, string> {

294 JSON.parseAs<LowerBridgeRequest>(text)

295}

296

SHA256 816061b5921aa25d775f53538a8bf5f733bf998d5b78024c34f09351cdbaeb75