gofront 0.0.7 → 0.0.9

package/src/templ-parser.js

@@ -0,0 +1,235 @@
+// Templ parser: extends the Go Parser to handle TemplDecl nodes.
+//
+// A .templ file is tokenised by TemplLexer into a mixed stream of standard Go
+// tokens (T.*) and HTML/templ tokens (TT.*). This parser handles TT.TEMPL_KW
+// in parseTopDecl; everything else is delegated to the base Parser.
+//
+// Produced AST additions:
+//   TemplDecl   { kind, name, params, body: TemplNode[] }
+//   TemplElement { kind, tag, attrs, children }
+//   TemplText   { kind, value }
+//   TemplExpr   { kind, tokens }          ← raw Go token array
+//   TemplComponent { kind, tokens }       ← raw Go token array for call
+//   TemplChildren  { kind }
+//   TemplIf     { kind, condTokens, then: TemplNode[], else_: TemplNode[] | null }
+//   TemplFor    { kind, stmtTokens, body: TemplNode[] }
+//   TemplSwitch { kind, exprTokens, cases: TemplCase[] }
+//   TemplCase   { kind, caseTokens: tokens | null (null = default), body: TemplNode[] }
+
+import { T } from "./lexer.js";
+import { Parser } from "./parser.js";
+import { TT } from "./templ-lexer.js";
+
+const VOID_ELEMENTS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr",
+]);
+
+export class TemplParser extends Parser {
+	// ── Top-level declaration override ───────────────────────────
+
+	parseTopDecl() {
+		if (this.check(TT.TEMPL_KW)) return this.parseTemplDecl();
+		return super.parseTopDecl();
+	}
+
+	// ── TemplDecl ─────────────────────────────────────────────────
+
+	parseTemplDecl() {
+		const _line = this.peek().line;
+		this.advance(); // consume TEMPL_KW
+
+		const name = this.expect(T.IDENT).value;
+
+		// Parse parameter list (standard Go params: LPAREN...RPAREN)
+		const params = this.parseParamList();
+
+		// Optional semicolon between ) and {
+		this.semi();
+
+		// Consume the opening { of the HTML body
+		this.expect(T.LBRACE);
+
+		// Parse the HTML body; parseHtmlChildren consumes the closing RBRACE
+		const body = this.parseHtmlChildren();
+
+		this.semi();
+
+		return { kind: "TemplDecl", name, params, body, _line };
+	}
+
+	// ── HTML node parsing ─────────────────────────────────────────
+
+	// Parse zero or more HTML nodes until RBRACE (end of body) or EOF.
+	// Consumes the RBRACE.
+	parseHtmlChildren() {
+		const nodes = [];
+		while (!this.check(T.RBRACE) && !this.check(T.EOF)) {
+			if (this.check(TT.TEMPL_ELSE)) break; // handled by caller (parseTemplIf)
+			const node = this.parseHtmlNode();
+			if (node) nodes.push(node);
+		}
+		if (this.check(T.RBRACE)) this.advance(); // consume }
+		return nodes;
+	}
+
+	// Parse a single HTML node from the current token.
+	parseHtmlNode() {
+		const t = this.peek();
+		switch (t.type) {
+			case TT.HTML_OPEN:
+				return this.parseHtmlElement();
+			case TT.HTML_SELF: {
+				this.advance();
+				return {
+					kind: "TemplElement",
+					tag: t.value.tag,
+					attrs: t.value.attrs,
+					children: [],
+				};
+			}
+			case TT.HTML_TEXT:
+				this.advance();
+				return { kind: "TemplText", value: t.value };
+			case TT.TEMPL_EXPR:
+				this.advance();
+				return { kind: "TemplExpr", tokens: t.value };
+			case TT.TEMPL_COMP:
+				this.advance();
+				return { kind: "TemplComponent", tokens: t.value };
+			case TT.TEMPL_CHILDREN:
+				this.advance();
+				return { kind: "TemplChildren" };
+			case TT.TEMPL_IF: {
+				this.advance();
+				return this.parseTemplIf(t);
+			}
+			case TT.TEMPL_FOR: {
+				this.advance();
+				return this.parseTemplFor(t);
+			}
+			case TT.TEMPL_SWITCH: {
+				this.advance();
+				return this.parseTemplSwitch(t);
+			}
+			default:
+				// Unknown token inside HTML body — skip it to avoid infinite loops
+				this.advance();
+				return null;
+		}
+	}
+
+	// Parse children of an element until the matching close tag.
+	parseHtmlElement() {
+		const openTok = this.advance(); // HTML_OPEN
+		const { tag, attrs } = openTok.value;
+
+		// Void elements have no children and no close tag even without />
+		if (VOID_ELEMENTS.has(tag)) {
+			return { kind: "TemplElement", tag, attrs, children: [] };
+		}
+
+		const children = [];
+		while (!this.check(T.EOF) && !this.check(T.RBRACE)) {
+			if (this.check(TT.HTML_CLOSE)) break;
+			// Also break on a close tag for a different ancestor (shouldn't happen in
+			// well-formed HTML, but prevents infinite loops on malformed input)
+			if (this.check(TT.TEMPL_ELSE)) break;
+			const node = this.parseHtmlNode();
+			if (node) children.push(node);
+		}
+		if (this.check(TT.HTML_CLOSE)) {
+			const closeTag = this.peek().value;
+			if (closeTag !== tag) {
+				throw new Error(
+					`${this.filename ?? "<templ>"}:${this.peek().line}: unclosed tag <${tag}>, got </${closeTag}>`,
+				);
+			}
+			this.advance(); // consume HTML_CLOSE
+		} else if (!VOID_ELEMENTS.has(tag)) {
+			// Non-void element with no close tag — parse error
+			throw new Error(
+				`${this.filename ?? "<templ>"}:${openTok.line}: unclosed tag <${tag}>`,
+			);
+		}
+		return { kind: "TemplElement", tag, attrs, children };
+	}
+
+	// Parse a TemplIf node. `tok` is the TEMPL_IF token (already advanced).
+	parseTemplIf(tok) {
+		const condTokens = tok.value; // array of Go tokens
+		const then = this.parseHtmlChildren(); // reads body until RBRACE
+		let else_ = null;
+		if (this.check(TT.TEMPL_ELSE)) {
+			this.advance(); // consume TEMPL_ELSE
+			if (this.check(TT.TEMPL_IF)) {
+				const t2 = this.advance();
+				else_ = [this.parseTemplIf(t2)]; // else if → wrap in array
+			} else {
+				else_ = this.parseHtmlChildren(); // else body until RBRACE
+			}
+		}
+		return { kind: "TemplIf", condTokens, then, else_ };
+	}
+
+	// Parse a TemplFor node. `tok` is the TEMPL_FOR token (already advanced).
+	parseTemplFor(tok) {
+		const stmtTokens = tok.value;
+		const body = this.parseHtmlChildren();
+		return { kind: "TemplFor", stmtTokens, body };
+	}
+
+	// Parse a TemplSwitch node. `tok` is the TEMPL_SWITCH token (already advanced).
+	parseTemplSwitch(tok) {
+		const exprTokens = tok.value;
+		const cases = [];
+		while (
+			!this.check(TT.TEMPL_END) &&
+			!this.check(T.RBRACE) &&
+			!this.check(T.EOF)
+		) {
+			if (this.check(TT.TEMPL_CASE)) {
+				const caseTok = this.advance();
+				const body = this.parseTemplCaseBody();
+				cases.push({ kind: "TemplCase", caseTokens: caseTok.value, body });
+			} else if (this.check(TT.TEMPL_DEFAULT)) {
+				this.advance();
+				const body = this.parseTemplCaseBody();
+				cases.push({ kind: "TemplCase", caseTokens: null, body });
+			} else {
+				this.advance(); // skip unexpected
+			}
+		}
+		if (this.check(TT.TEMPL_END)) this.advance(); // consume closing }
+		return { kind: "TemplSwitch", exprTokens, cases };
+	}
+
+	// Parse HTML nodes for a switch case body — stops at CASE/DEFAULT/END/RBRACE.
+	parseTemplCaseBody() {
+		const nodes = [];
+		while (
+			!this.check(TT.TEMPL_CASE) &&
+			!this.check(TT.TEMPL_DEFAULT) &&
+			!this.check(TT.TEMPL_END) &&
+			!this.check(T.RBRACE) &&
+			!this.check(T.EOF)
+		) {
+			if (this.check(TT.TEMPL_ELSE)) break;
+			const node = this.parseHtmlNode();
+			if (node) nodes.push(node);
+		}
+		return nodes;
+	}
+}

package/src/typechecker/stdlib.js

@@ -8,6 +8,9 @@
 
 import { ANY, BOOL, ERROR, FLOAT64, INT, STRING, VOID } from "./types.js";
 
+// time.Time named type — used by the time package
+const TIME_T = { kind: "named", name: "time.Time", underlying: ANY };
+
 export function setupGlobals(globals, types) {
 	// Browser globals — typed as 'any' so any access/call is permitted
 	const browserGlobals = [
@@ -113,6 +116,24 @@ export function setupGlobals(globals, types) {
 				returns: [INT, ERROR],
 				variadic: true,
 			},
+			Sscan: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT, ERROR],
+				variadic: true,
+			},
+			Sscanln: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT, ERROR],
+				variadic: true,
+			},
+			Sscanf: {
+				kind: "func",
+				params: [STRING, STRING, ANY],
+				returns: [INT, ERROR],
+				variadic: true,
+			},
 		},
 	});
 
@@ -164,6 +185,71 @@ export function setupGlobals(globals, types) {
 				returns: [STRING],
 			},
 			EqualFold: strFn2(STRING, BOOL),
+			Fields: strFn1({ kind: "slice", elem: STRING }),
+			Cut: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [STRING, STRING, BOOL],
+			},
+			CutPrefix: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [STRING, BOOL],
+			},
+			CutSuffix: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [STRING, BOOL],
+			},
+			SplitN: strFn3(STRING, INT, { kind: "slice", elem: STRING }),
+			SplitAfter: strFn2(STRING, { kind: "slice", elem: STRING }),
+			SplitAfterN: strFn3(STRING, INT, { kind: "slice", elem: STRING }),
+			IndexAny: strFn2(STRING, INT),
+			LastIndexAny: strFn2(STRING, INT),
+			ContainsAny: strFn2(STRING, BOOL),
+			ContainsRune: strFn2(INT, BOOL),
+			IndexRune: strFn2(INT, INT),
+			IndexByte: strFn2(INT, INT),
+			LastIndexByte: strFn2(INT, INT),
+			Map: {
+				kind: "func",
+				params: [ANY, STRING],
+				returns: [STRING],
+			},
+			Title: strFn1(STRING),
+			ToTitle: strFn1(STRING),
+			TrimFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [STRING],
+			},
+			TrimLeftFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [STRING],
+			},
+			TrimRightFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [STRING],
+			},
+			IndexFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT],
+			},
+			LastIndexFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT],
+			},
+			NewReplacer: {
+				kind: "func",
+				params: [STRING],
+				returns: [ANY],
+				variadic: true,
+			},
+			NewReader: { kind: "func", params: [STRING], returns: [ANY] },
 		},
 	});
 
@@ -205,6 +291,46 @@ export function setupGlobals(globals, types) {
 				params: [{ kind: "slice", elem: BYTE_SLICE }, BYTE_SLICE],
 				returns: [BYTE_SLICE],
 			},
+			ReplaceAll: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE, BYTE_SLICE],
+				returns: [BYTE_SLICE],
+			},
+			TrimPrefix: byFn2(BYTE_SLICE, BYTE_SLICE),
+			TrimSuffix: byFn2(BYTE_SLICE, BYTE_SLICE),
+			TrimLeft: byFn2(STRING, BYTE_SLICE),
+			TrimRight: byFn2(STRING, BYTE_SLICE),
+			TrimFunc: {
+				kind: "func",
+				params: [BYTE_SLICE, ANY],
+				returns: [BYTE_SLICE],
+			},
+			IndexByte: byFn2(INT, INT),
+			LastIndex: byFn2(BYTE_SLICE, INT),
+			LastIndexByte: byFn2(INT, INT),
+			Fields: byFn1({ kind: "slice", elem: BYTE_SLICE }),
+			Cut: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE],
+				returns: [BYTE_SLICE, BYTE_SLICE, BOOL],
+			},
+			ContainsAny: byFn2(STRING, BOOL),
+			ContainsRune: byFn2(INT, BOOL),
+			Map: {
+				kind: "func",
+				params: [ANY, BYTE_SLICE],
+				returns: [BYTE_SLICE],
+			},
+			SplitN: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE, INT],
+				returns: [{ kind: "slice", elem: BYTE_SLICE }],
+			},
+			NewReader: {
+				kind: "func",
+				params: [BYTE_SLICE],
+				returns: [ANY],
+			},
 		},
 	});
 
@@ -241,6 +367,22 @@ export function setupGlobals(globals, types) {
 				params: [STRING],
 				returns: [BOOL, ERROR],
 			},
+			Quote: { kind: "func", params: [STRING], returns: [STRING] },
+			Unquote: {
+				kind: "func",
+				params: [STRING],
+				returns: [STRING, ERROR],
+			},
+			AppendInt: {
+				kind: "func",
+				params: [{ kind: "slice", elem: INT }, INT, INT],
+				returns: [{ kind: "slice", elem: INT }],
+			},
+			AppendFloat: {
+				kind: "func",
+				params: [{ kind: "slice", elem: INT }, FLOAT64, INT, INT, INT],
+				returns: [{ kind: "slice", elem: INT }],
+			},
 		},
 	});
 
@@ -279,6 +421,26 @@ export function setupGlobals(globals, types) {
 				params: [ANY, ANY],
 				returns: [BOOL],
 			},
+			Search: {
+				kind: "func",
+				params: [INT, ANY],
+				returns: [INT],
+			},
+			IntsAreSorted: {
+				kind: "func",
+				params: [{ kind: "slice", elem: INT }],
+				returns: [BOOL],
+			},
+			Float64sAreSorted: {
+				kind: "func",
+				params: [{ kind: "slice", elem: FLOAT64 }],
+				returns: [BOOL],
+			},
+			StringsAreSorted: {
+				kind: "func",
+				params: [{ kind: "slice", elem: STRING }],
+				returns: [BOOL],
+			},
 		},
 	});
 
@@ -327,6 +489,26 @@ export function setupGlobals(globals, types) {
 				returns: [BOOL],
 			},
 			NaN: { kind: "func", params: [], returns: [FLOAT64] },
+			Atan: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Atan2: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
+			Asin: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Acos: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Exp: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Exp2: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Trunc: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Hypot: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
+			Signbit: { kind: "func", params: [FLOAT64], returns: [BOOL] },
+			Copysign: {
+				kind: "func",
+				params: [FLOAT64, FLOAT64],
+				returns: [FLOAT64],
+			},
+			Dim: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
+			Remainder: {
+				kind: "func",
+				params: [FLOAT64, FLOAT64],
+				returns: [FLOAT64],
+			},
 			// Constants
 			Pi: FLOAT64,
 			E: FLOAT64,
@@ -353,15 +535,57 @@ export function setupGlobals(globals, types) {
 		kind: "namespace",
 		name: "time",
 		members: {
-			Now: { kind: "func", params: [], returns: [ANY] },
-			Since: { kind: "func", params: [ANY], returns: [ANY] },
+			Now: { kind: "func", params: [], returns: [TIME_T] },
+			Since: { kind: "func", params: [TIME_T], returns: [INT] },
 			Sleep: { kind: "func", params: [ANY], returns: [VOID], async: true },
+			Parse: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [TIME_T, ERROR],
+			},
+			Unix: { kind: "func", params: [INT, INT], returns: [TIME_T] },
+			Date: {
+				kind: "func",
+				params: [INT, INT, INT, INT, INT, INT, INT, ANY],
+				returns: [TIME_T],
+			},
 			Millisecond: INT,
 			Second: INT,
 			Minute: INT,
 			Hour: INT,
+			// Layout constants
+			RFC3339: STRING,
+			RFC3339Nano: STRING,
+			DateOnly: STRING,
+			TimeOnly: STRING,
+			DateTime: STRING,
+			// Location constants
+			UTC: ANY,
+			Local: ANY,
+			// Month constants
+			January: INT,
+			February: INT,
+			March: INT,
+			April: INT,
+			May: INT,
+			June: INT,
+			July: INT,
+			August: INT,
+			September: INT,
+			October: INT,
+			November: INT,
+			December: INT,
+			// Weekday constants
+			Sunday: INT,
+			Monday: INT,
+			Tuesday: INT,
+			Wednesday: INT,
+			Thursday: INT,
+			Friday: INT,
+			Saturday: INT,
 		},
 	});
+	types.set("time.Time", TIME_T);
 
 	// unicode package
 	const runeToStr = { kind: "func", params: [INT], returns: [BOOL] };
@@ -455,22 +679,30 @@ export function setupGlobals(globals, types) {
 	// io package — Writer interface + WriteString
 	// io.Writer is typed as ANY so GoFront's built-in writer types (strings.Builder,
 	// bytes.Buffer) are accepted without explicit interface-satisfaction registration.
+	const BYTE_SLICE_IO = { kind: "slice", elem: INT };
 	globals.define("io", {
 		kind: "namespace",
 		name: "io",
 		members: {
 			Writer: ANY,
+			Reader: ANY,
 			EOF: ERROR,
 			WriteString: {
 				kind: "func",
 				params: [ANY, STRING],
 				returns: [INT, ERROR],
 			},
+			ReadAll: {
+				kind: "func",
+				params: [ANY],
+				returns: [BYTE_SLICE_IO, ERROR],
+			},
 			Discard: ANY,
 		},
 	});
 	// Register io.Writer as a type alias so it resolves in parameter/field annotations.
 	types.set("io.Writer", ANY);
+	types.set("io.Reader", ANY);
 
 	// gom package — browser-native component built-in
 	const GOM_NODE_T = {
@@ -742,6 +974,77 @@ export function setupGlobals(globals, types) {
 		},
 	});
 
+	// math/rand package — import "math/rand" → local name "rand"
+	globals.define("rand", {
+		kind: "namespace",
+		name: "rand",
+		members: {
+			Intn: { kind: "func", params: [INT], returns: [INT] },
+			Float64: { kind: "func", params: [], returns: [FLOAT64] },
+			Float32: { kind: "func", params: [], returns: [FLOAT64] },
+			Int: { kind: "func", params: [], returns: [INT] },
+			Int63: { kind: "func", params: [], returns: [INT] },
+			Int63n: { kind: "func", params: [INT], returns: [INT] },
+			Int31: { kind: "func", params: [], returns: [INT] },
+			Int31n: { kind: "func", params: [INT], returns: [INT] },
+			Seed: { kind: "func", params: [INT], returns: [VOID] },
+			Shuffle: { kind: "func", params: [INT, ANY], returns: [VOID] },
+			Perm: {
+				kind: "func",
+				params: [INT],
+				returns: [{ kind: "slice", elem: INT }],
+			},
+		},
+	});
+
+	// unicode/utf8 package — import "unicode/utf8" → local name "utf8"
+	globals.define("utf8", {
+		kind: "namespace",
+		name: "utf8",
+		members: {
+			RuneCountInString: { kind: "func", params: [STRING], returns: [INT] },
+			RuneLen: { kind: "func", params: [INT], returns: [INT] },
+			ValidString: { kind: "func", params: [STRING], returns: [BOOL] },
+			ValidRune: { kind: "func", params: [INT], returns: [BOOL] },
+			DecodeRuneInString: {
+				kind: "func",
+				params: [STRING],
+				returns: [INT, INT],
+			},
+			DecodeLastRuneInString: {
+				kind: "func",
+				params: [STRING],
+				returns: [INT, INT],
+			},
+			FullRuneInString: { kind: "func", params: [STRING], returns: [BOOL] },
+			// Constants
+			RuneError: INT,
+			MaxRune: INT,
+			UTFMax: INT,
+		},
+	});
+
+	// path package — import "path" or "path/filepath" → local name "path"
+	globals.define("path", {
+		kind: "namespace",
+		name: "path",
+		members: {
+			Base: { kind: "func", params: [STRING], returns: [STRING] },
+			Dir: { kind: "func", params: [STRING], returns: [STRING] },
+			Ext: { kind: "func", params: [STRING], returns: [STRING] },
+			Join: {
+				kind: "func",
+				params: [STRING],
+				returns: [STRING],
+				variadic: true,
+			},
+			Clean: { kind: "func", params: [STRING], returns: [STRING] },
+			IsAbs: { kind: "func", params: [STRING], returns: [BOOL] },
+			Split: { kind: "func", params: [STRING], returns: [STRING, STRING] },
+			Match: { kind: "func", params: [STRING, STRING], returns: [BOOL, ERROR] },
+		},
+	});
+
 	// Built-in functions
 	globals.define("append", { kind: "builtin", name: "append" });
 	globals.define("len", { kind: "builtin", name: "len" });

package/src/typechecker/types.js

@@ -15,19 +15,22 @@
 export class TypeCheckError extends Error {
 	constructor(msg, node, filename, sourceCode) {
 		const lineNum = node?.line || node?._line;
+		const colNum = node?.col || node?._col;
 		const loc = filename
 			? lineNum
-				? ` in ${filename} at line ${lineNum}`
+				? ` in ${filename} at line ${lineNum}:${colNum ?? 1}`
 				: ` in ${filename}`
 			: lineNum
-				? ` at line ${lineNum}`
+				? ` at line ${lineNum}:${colNum ?? 1}`
 				: "";
 		let lineContext = "";
 		if (lineNum && sourceCode) {
 			const lines = sourceCode.split("\n");
 			const lineStr = lines[lineNum - 1];
 			if (lineStr !== undefined) {
-				lineContext = `\n  ${lineNum} | ${lineStr}`;
+				const prefix = `  ${lineNum} | `;
+				const caretPad = " ".repeat((colNum ?? 1) - 1);
+				lineContext = `\n${prefix}${lineStr}\n${" ".repeat(prefix.length)}${caretPad}^`;
 			}
 		}
 		super(`Type error${loc}: ${msg}${lineContext}`);
@@ -93,14 +96,6 @@ export const BASIC_TYPES = {
 
 export const COMPARABLE = { kind: "basic", name: "comparable" };
 
-export function isTypeParam(t) {
-	return t?.kind === "typeParam";
-}
-
-export function isGeneric(t) {
-	return t?.kind === "generic";
-}
-
 function makeBasicPredicate(...names) {
 	const set = new Set(names);
 	const pred = (t) => {
@@ -137,13 +132,6 @@ export function isNil(t) {
 export function isVoid(t) {
 	return t?.kind === "basic" && t.name === "void";
 }
-export function isError(t) {
-	if (!t) return false;
-	if (t === ERROR) return true;
-	if (t.kind === "interface" && t.name === "error") return true;
-	if (t.kind === "named" && isError(t.underlying)) return true;
-	return false;
-}
 export function isPointer(t) {
 	if (!t) return false;
 	if (t.kind === "pointer") return true;