slow.monster

STUDIO HAZE · topaz

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 50 files

Compiler sources from the Topaz 5.21.0 release. Compatibility code for earlier language modes is retained.

Publication edits are limited to explanatory comments. Executable code is unchanged.
Rights and source notices · Source manifest

compiler/crates/topaz_self_frontend/topaz/checker/builtin_signatures.tpz

Topaz · 19672 B · Published file

1// Pure parameter/default metadata shared by direct and bound builtin calls.
2import checker_types { TypeValue }
3import checker.model { CallSignature, lengthUnit }
5export function stringElementType(value: TypeValue) -> bool {
6 if value.kind == "primitive" || value.kind == "literal" { return value.name == "string" }
7 if value.kind != "union" || value.members.length == 0 { return false }
8 for member in value.members { if !stringElementType(member) { return false } }
9 true
12export function builtinNamespaceFamily(namespace: string) -> string {
13 match namespace {
14 case "Array" | "Set" | "Bytes" | "ByteBuffer" | "Map" =>
15 "collection"
16 case "Math" | "Codec" | "Hash" => "numeric-binary"
17 case "FS" | "Encoding" | "Cli" | "Path" | "Regex" => "host"
18 case "CSV" | "TOML" | "JSON" => "structured-data"
19 case "URL" | "Date" | "BigInt" | "Decimal" | "RoundingMode" |
20 "Test" => "scalar"
21 case "Show" | "Eq" | "Order" => "protocol"
22 case _ => ""
23 }
26export function requiredCallSignature(
27 parameterNames: Array<string>,
28 variadic: bool,
29) -> CallSignature {
30 let mut defaults: Array<bool> = []
31 for _ in parameterNames {
32 defaults.push(false)
33 }
34 CallSignature {
35 parameterNames: parameterNames,
36 parameterDefaults: defaults,
37 parameterCount: parameterNames.length,
38 variadic: variadic,
39 positionalOnlyIdentity: "",
40 }
43export function defaultedCallSignature(
44 parameterNames: Array<string>,
45 parameterDefaults: Array<bool>,
46) -> CallSignature {
47 CallSignature {
48 parameterNames: parameterNames,
49 parameterDefaults: parameterDefaults,
50 parameterCount: parameterNames.length,
51 variadic: false,
52 positionalOnlyIdentity: "",
53 }
56export function positionalOnlyCallSignature(
57 identity: string,
58 parameterNames: Array<string>,
59) -> CallSignature {
60 CallSignature {
61 ...requiredCallSignature(parameterNames, false),
62 positionalOnlyIdentity: identity,
63 }
66function collectionStaticCallSignature(
67 namespace: string,
68 name: string,
69) -> Option<CallSignature> {
70 if (namespace == "Array" || namespace == "Set") && name == "of" {
71 return Some(requiredCallSignature([], true))
72 }
73 if namespace == "Map" {
74 return match name {
75 case "new" => Some(requiredCallSignature([], false))
76 case "ofEntries" => Some(requiredCallSignature(["entries"], false))
77 case _ => None
78 }
79 }
80 if namespace == "Bytes" {
81 return match name {
82 case "empty" => Some(requiredCallSignature([], false))
83 case "encodeUtf8" | "fromHex" | "fromBase64" =>
84 Some(requiredCallSignature(["s"], false))
85 case "fromArray" => Some(requiredCallSignature(["values"], false))
86 case "concat" => Some(requiredCallSignature(["a", "b"], false))
87 case _ => None
88 }
89 }
90 if namespace == "ByteBuffer" {
91 return match name {
92 case "allocate" => Some(defaultedCallSignature(
93 ["length", "value"],
94 [false, true],
95 ))
96 case "fromBytes" => Some(requiredCallSignature(["value"], false))
97 case _ => None
98 }
99 }
100 None
103function numericBinaryStaticCallSignature(
104 namespace: string,
105 name: string,
106) -> Option<CallSignature> {
107 if namespace == "Math" {
108 return match name {
109 case "sqrt" | "abs" | "floor" | "ceil" | "round" |
110 "sin" | "cos" | "tan" | "isNaN" | "isFinite" =>
111 Some(requiredCallSignature(["x"], false))
112 case "parseFloat" => Some(requiredCallSignature(["s"], false))
113 case "min" | "max" => Some(requiredCallSignature(["a", "b"], false))
114 case _ => None
115 }
116 }
117 if namespace == "Codec" {
118 return match name {
119 case "zstdCompress" => Some(defaultedCallSignature(
120 ["bytes", "level"],
121 [false, true],
122 ))
123 case "gzipCompress" | "gzipDecompress" | "deflateCompress" |
124 "deflateFixedCompress" | "zlibFixedCompress" |
125 "reedSolomon255223Protect" | "deflateDecompress" |
126 "zstdDecompress" => Some(requiredCallSignature(["bytes"], false))
127 case _ => None
128 }
129 }
130 if namespace == "Hash" {
131 return match name {
132 case "sha256" | "sha512" | "crc32" =>
133 Some(requiredCallSignature(["data"], false))
134 case "hmacSha256" => Some(requiredCallSignature(
135 ["key", "message"],
136 false,
137 ))
138 case _ => None
139 }
140 }
141 None
144function hostStaticCallSignature(
145 namespace: string,
146 name: string,
147) -> Option<CallSignature> {
148 if namespace == "FS" {
149 return match name {
150 case "readText" | "readBytes" | "list" =>
151 Some(requiredCallSignature(["path"], false))
152 case "writeText" => Some(requiredCallSignature(
153 ["path", "text"],
154 false,
155 ))
156 case "writeBytes" => Some(requiredCallSignature(
157 ["path", "bytes"],
158 false,
159 ))
160 case _ => None
161 }
162 }
163 if namespace == "Encoding" {
164 return match name {
165 case "utf8Encode" | "hexDecode" | "base64Decode" =>
166 Some(requiredCallSignature(["text"], false))
167 case "utf8Decode" | "hexEncode" | "base64Encode" =>
168 Some(requiredCallSignature(["bytes"], false))
169 case _ => None
170 }
171 }
172 if namespace == "Cli" {
173 return match name {
174 case "hasFlag" | "option" | "options" =>
175 Some(requiredCallSignature(["args", "name"], false))
176 case "positionals" => Some(requiredCallSignature(["args"], false))
177 case _ => None
178 }
179 }
180 if namespace == "Path" &&
181 (name == "from" || name == "cwdRelative" || name == "project") {
182 return Some(requiredCallSignature(["text"], false))
183 }
184 if namespace == "Regex" && name == "compile" {
185 return Some(requiredCallSignature(["pattern"], false))
186 }
187 None
190function structuredDataStaticCallSignature(
191 namespace: string,
192 name: string,
193) -> Option<CallSignature> {
194 if namespace == "CSV" {
195 return match name {
196 case "parse" | "parseWithHeader" =>
197 Some(requiredCallSignature(["text"], false))
198 case "stringify" => Some(requiredCallSignature(["rows"], false))
199 case "stringifyWithHeader" => Some(requiredCallSignature(
200 ["rows", "columns"],
201 false,
202 ))
203 case _ => None
204 }
205 }
206 if namespace == "TOML" {
207 return match name {
208 case "parse" => Some(requiredCallSignature(["text"], false))
209 case "stringify" | "toJson" | "fromJson" =>
210 Some(requiredCallSignature(["value"], false))
211 case _ => None
212 }
213 }
214 if namespace == "JSON" {
215 return match name {
216 case "parseAs" | "parse" =>
217 Some(requiredCallSignature(["text"], false))
218 case "decode" | "stringify" =>
219 Some(requiredCallSignature(["value"], false))
220 case _ => None
221 }
222 }
223 None
226function scalarTestStaticCallSignature(
227 namespace: string,
228 name: string,
229) -> Option<CallSignature> {
230 if namespace == "URL" && name == "parse" {
231 return Some(requiredCallSignature(["text"], false))
232 }
233 if namespace == "Date" {
234 return match name {
235 case "fromYmd" => Some(requiredCallSignature(
236 ["year", "month", "day"],
237 false,
238 ))
239 case "parseIso" => Some(requiredCallSignature(["text"], false))
240 case _ => None
241 }
242 }
243 if namespace == "BigInt" {
244 return match name {
245 case "fromInt" => Some(requiredCallSignature(["n"], false))
246 case "parse" => Some(requiredCallSignature(["text", "radix"], false))
247 case _ => None
248 }
249 }
250 if namespace == "Decimal" {
251 return match name {
252 case "fromInt" => Some(requiredCallSignature(["n"], false))
253 case "parse" => Some(requiredCallSignature(["text"], false))
254 case _ => None
255 }
256 }
257 if namespace == "Test" {
258 return match name {
259 case "assert" => Some(defaultedCallSignature(
260 ["condition", "message"],
261 [false, true],
262 ))
263 case "assertEq" | "assertNe" => Some(requiredCallSignature(
264 ["actual", "expected"],
265 false,
266 ))
267 case "assertContains" => Some(requiredCallSignature(
268 ["text", "needle"],
269 false,
270 ))
271 case "assertOk" | "assertErr" | "assertSome" | "assertNone" =>
272 Some(requiredCallSignature(["value"], false))
273 case "assertGolden" => Some(requiredCallSignature(
274 ["path", "actual"],
275 false,
276 ))
277 case _ => None
278 }
279 }
280 None
283function containerReceiverCallSignature(
284 receiver: TypeValue,
285 name: string,
286) -> Option<CallSignature> {
287 if receiver.kind != "constructor" {
288 return None
289 }
290 if receiver.name == "Option" {
291 return match name {
292 case "okOr" => Some(requiredCallSignature(["error"], false))
293 case "okOrElse" | "map" | "flatMap" =>
294 Some(requiredCallSignature(["f"], false))
295 case _ => None
296 }
297 }
298 if receiver.name == "Result" {
299 return match name {
300 case "map" | "flatMap" => Some(requiredCallSignature(["f"], false))
301 case _ => None
302 }
303 }
304 if receiver.name == "Array" {
305 return match name {
306 case "get" => Some(requiredCallSignature(["i"], false))
307 case "slice" => Some(requiredCallSignature(["start", "end"], false))
308 case "map" | "sortedBy" | "filter" | "sortBy" | "retain" =>
309 Some(requiredCallSignature(["f"], false))
310 case "join" => Some(requiredCallSignature(["sep"], false))
311 case "reduce" => Some(requiredCallSignature(["initial", "f"], false))
312 case "indexOf" | "push" => Some(requiredCallSignature(["x"], false))
313 case "insert" => Some(requiredCallSignature(
314 ["index", "value"],
315 false,
316 ))
317 case "removeAt" => Some(requiredCallSignature(["index"], false))
318 case "sorted" | "pop" | "clear" | "reverse" | "sort" =>
319 Some(requiredCallSignature([], false))
320 case _ => None
321 }
322 }
323 if receiver.name == "Map" {
324 return match name {
325 case "insert" => Some(requiredCallSignature(["k", "v"], false))
326 case "get" | "remove" | "containsKey" =>
327 Some(requiredCallSignature(["k"], false))
328 case "getOr" => Some(requiredCallSignature(["k", "default"], false))
329 case "isEmpty" | "clear" => Some(requiredCallSignature([], false))
330 case "update" => Some(requiredCallSignature(
331 ["k", "initial", "f"],
332 false,
333 ))
334 case "mapValues" | "filter" =>
335 Some(requiredCallSignature(["f"], false))
336 case _ => None
337 }
338 }
339 if receiver.name == "Set" {
340 return match name {
341 case "add" | "remove" | "contains" =>
342 Some(requiredCallSignature(["x"], false))
343 case "union" | "intersection" | "difference" =>
344 Some(requiredCallSignature(["other"], false))
345 case "isEmpty" | "toArray" | "clear" =>
346 Some(requiredCallSignature([], false))
347 case _ => None
348 }
349 }
350 None
353function scalarReceiverCallSignature(
354 receiver: TypeValue,
355 name: string,
356) -> Option<CallSignature> {
357 if (receiver.kind == "primitive" || receiver.kind == "literal") &&
358 receiver.name == "int" {
359 return match name {
360 case "atLeast" => Some(requiredCallSignature(["min"], false))
361 case "atMost" => Some(requiredCallSignature(["max"], false))
362 case _ => None
363 }
364 }
365 if (receiver.kind == "primitive" || receiver.kind == "literal") &&
366 receiver.name == "string" {
367 return match name {
368 case "startsWith" => Some(requiredCallSignature(["prefix"], false))
369 case "endsWith" => Some(requiredCallSignature(["suffix"], false))
370 case "contains" | "indexOf" | "lastIndexOf" =>
371 Some(requiredCallSignature(["sub"], false))
372 case "codePointAt" => Some(requiredCallSignature(["i"], false))
373 case "split" => Some(requiredCallSignature(["sep"], false))
374 case "slice" => Some(requiredCallSignature(["start", "end"], false))
375 case "replace" => Some(requiredCallSignature(["old", "new"], false))
376 case "scalars" | "trim" | "trimStart" | "trimEnd" | "byteLength" =>
377 Some(requiredCallSignature([], false))
378 case _ => None
379 }
380 }
381 None
384function runtimeReceiverCallSignature(
385 receiver: TypeValue,
386 name: string,
387) -> Option<CallSignature> {
388 if receiver.kind == "file" {
389 return match name {
390 case "write" => Some(requiredCallSignature(["s"], false))
391 case "read" | "close" => Some(requiredCallSignature([], false))
392 case _ => None
393 }
394 }
395 if receiver.kind == "json-value" {
396 return match name {
397 case "get" => Some(requiredCallSignature(["key"], false))
398 case "at" => Some(requiredCallSignature(["index"], false))
399 case "kind" | "isNull" | "asString" | "asBool" | "asInt" |
400 "numberText" | "length" | "asArray" | "keys" | "values" =>
401 Some(requiredCallSignature([], false))
402 case _ => None
403 }
404 }
405 if receiver.kind == "bytes" {
406 return match name {
407 case "get" => Some(requiredCallSignature(["index"], false))
408 case "slice" => Some(requiredCallSignature(["start", "end"], false))
409 case "decodeUtf8" | "toHex" | "toBase64" | "length" |
410 "isEmpty" | "toArray" => Some(requiredCallSignature([], false))
411 case _ => None
412 }
413 }
414 if receiver.kind == "byte-buffer" {
415 return match name {
416 case "get" => Some(requiredCallSignature(["index"], false))
417 case "set" => Some(requiredCallSignature(["index", "value"], false))
418 case "fill" => Some(requiredCallSignature(
419 ["start", "length", "value"],
420 false,
421 ))
422 case "copy" => Some(requiredCallSignature(
423 ["source", "sourceStart", "targetStart", "length"],
424 false,
425 ))
426 case "length" | "toBytes" => Some(requiredCallSignature([], false))
427 case _ => None
428 }
429 }
430 if receiver.kind == "path" {
431 return match name {
432 case "join" => Some(requiredCallSignature(["child"], false))
433 case "withExtension" => Some(requiredCallSignature(["ext"], false))
434 case "parent" | "fileName" | "extension" | "normalize" | "toString" =>
435 Some(requiredCallSignature([], false))
436 case _ => None
437 }
438 }
439 if receiver.kind == "regex" {
440 return match name {
441 case "isMatch" | "find" | "findAll" | "split" =>
442 Some(requiredCallSignature(["text"], false))
443 case "replaceAll" => Some(requiredCallSignature(
444 ["text", "replacement"],
445 false,
446 ))
447 case _ => None
448 }
449 }
450 if receiver.kind == "url" {
451 return match name {
452 case "scheme" | "path" | "toString" | "host" | "fragment" | "query" =>
453 Some(requiredCallSignature([], false))
454 case _ => None
455 }
456 }
457 if receiver.kind == "date" {
458 return match name {
459 case "addDays" => Some(requiredCallSignature(["days"], false))
460 case "toIso" | "year" | "month" | "day" =>
461 Some(requiredCallSignature([], false))
462 case _ => None
463 }
464 }
465 if receiver.kind == "big-int" {
466 return match name {
467 case "toString" => Some(requiredCallSignature(["radix"], false))
468 case "div" | "mod" => Some(requiredCallSignature(["other"], false))
469 case "toInt" => Some(requiredCallSignature([], false))
470 case _ => None
471 }
472 }
473 if receiver.kind == "decimal" {
474 return match name {
475 case "round" => Some(defaultedCallSignature(
476 ["scale", "mode"],
477 [false, true],
478 ))
479 case "div" => Some(defaultedCallSignature(
480 ["other", "scale", "mode"],
481 [false, false, true],
482 ))
483 case "toString" | "scale" | "toInt" =>
484 Some(requiredCallSignature([], false))
485 case _ => None
486 }
487 }
488 None
491export function builtinReceiverCallSignature(
492 receiver: TypeValue,
493 name: string,
494 languageMode: string = "topaz-5.20",
495) -> Option<CallSignature> {
496 if languageMode == "topaz-5.21" {
497 if receiver.name == "int" {
498 if name == "and" || name == "or" || name == "xor" { return Some(requiredCallSignature(["other"], false)) }
499 if name == "shift" { return Some(requiredCallSignature(["count"], false)) }
500 if name == "toBigInt" || name == "toDecimal" { return Some(requiredCallSignature([], false)) }
501 }
502 if receiver.name == "string" && name == "encodeUtf8" { return Some(requiredCallSignature([], false)) }
503 if receiver.kind == "constructor" && (receiver.name == "Set" || receiver.name == "Range") {
504 if name == "map" || name == "filter" { return Some(requiredCallSignature(["f"], false)) }
505 if name == "reduce" { return Some(requiredCallSignature(["initial", "f"], false)) }
506 }
507 if receiver.kind == "constructor" && receiver.name == "Result" {
508 if name == "mapErr" { return Some(requiredCallSignature(["f"], false)) }
509 if name == "unwrapOr" { return Some(requiredCallSignature(["default"], false)) }
510 }
511 if receiver.kind == "constructor" && receiver.name == "Array" && receiver.arguments.length == 1 && stringElementType(receiver.arguments[0]) {
512 if name == "hasFlag" || name == "option" || name == "options" { return Some(requiredCallSignature(["name"], false)) }
513 if name == "positionals" { return Some(requiredCallSignature([], false)) }
514 }
515 if receiver.kind == "bytes" {
516 if name == "concat" { return Some(requiredCallSignature(["b"], false)) }
517 if name == "hmacSha256" { return Some(requiredCallSignature(["message"], false)) }
518 if name == "zstdCompress" { return Some(defaultedCallSignature(["level"], [true])) }
519 if name == "sha256" || name == "sha512" || name == "crc32" || name == "gzipCompress" || name == "gzipDecompress" || name == "deflateCompress" || name == "deflateFixedCompress" || name == "zlibFixedCompress" || name == "reedSolomon255223Protect" || name == "deflateDecompress" || name == "zstdDecompress" { return Some(requiredCallSignature([], false)) }
520 }
521 if (receiver.kind == "json-value" && name == "decode") || (receiver.kind == "toml-value" && name == "toJson") { return Some(requiredCallSignature([], false)) }
522 if lengthUnit(receiver) != "" {return if name == "resolve" {Some(requiredCallSignature(["fontSize"],false))} else {Some(requiredCallSignature([],false))}}
523 if receiver.name == "float" {
524 if name == "atMost" || name == "atLeast" { return Some(requiredCallSignature(["b"], false)) }
525 if name == "trunc" || name == "floor" || name == "ceil" || name == "round" || name == "sqrt" || name == "abs" || name == "sin" || name == "cos" || name == "tan" || name == "isNaN" || name == "isFinite" { return Some(requiredCallSignature([], false)) }
526 }
527 if receiver.name == "int" && (name == "toFloat" || name == "toCodePoint") { return Some(requiredCallSignature([], false)) }
528 if receiver.name == "string" {
529 if name == "parseFloat" || name == "toInt" { return Some(requiredCallSignature([], false)) }
530 if name == "toIntRadix" { return Some(requiredCallSignature(["radix"], false)) }
531 }
532 }
533 if receiver.kind == "union" {
534 for member in receiver.members {
535 match builtinReceiverCallSignature(member, name, languageMode) {
536 case Some(found) => return Some(found)
537 case None => ()
538 }
539 }
540 return None
541 }
542 match containerReceiverCallSignature(receiver, name) {
543 case Some(found) => return Some(found)
544 case None => ()
545 }
546 match scalarReceiverCallSignature(receiver, name) {
547 case Some(found) => return Some(found)
548 case None => ()
549 }
550 runtimeReceiverCallSignature(receiver, name)
554export function staticBuiltinDataCallSignature(namespace: string, name: string) -> Option<CallSignature> {
555 match builtinNamespaceFamily(namespace) {
556 case "collection" => collectionStaticCallSignature(namespace, name)
557 case "numeric-binary" => numericBinaryStaticCallSignature(namespace, name)
558 case "host" => hostStaticCallSignature(namespace, name)
559 case "structured-data" => structuredDataStaticCallSignature(namespace, name)
560 case "scalar" => scalarTestStaticCallSignature(namespace, name)
561 case _ => None
562 }

SHA256 d39c56a894a273ca893f9d44a1b49524479515010e8298f01ea597887982d8ad