@starpak/lang 0.0.0-stage → 0.1.2

package/src/token.ts

@@ -0,0 +1,34 @@
+/**
+ * Spak Lang - Token definitions
+ */
+
+export const TokenType = {
+  Number: 'Number',
+  String: 'String',
+  FString: 'FString',
+  Identifier: 'Identifier',
+  Keyword: 'Keyword',
+  Operator: 'Operator',
+  Newline: 'Newline',
+  Semicolon: 'Semicolon',
+  EOF: 'EOF',
+} as const
+
+export type TokenType = typeof TokenType[keyof typeof TokenType]
+
+export interface Token {
+  type: TokenType
+  /** Raw lexeme for identifiers/keywords/operators, decoded content for strings. */
+  value: string
+  /** 1-based line of the first character. */
+  line: number
+  /** 1-based column of the first character. */
+  column: number
+  /** Character offset of the first character. */
+  start: number
+  /** Character offset just past the last character. */
+  end: number
+  fstring?: boolean
+  /** Doc comment (`---`) that directly precedes this token, if any. */
+  doc?: string
+}

package/src/types.ts

@@ -0,0 +1,218 @@
+/**
+ * Spak Lang - Type model and compatibility rules (M2)
+ *
+ * Types only exist at check time; nothing here is emitted to runtime code.
+ * The model mirrors `docs/syntax/typecheck.md`.
+ */
+
+import type { TypeAnn } from './ast'
+
+export type Type =
+  | AnyType
+  | NilType
+  | PrimType
+  | ArrayType
+  | DictType
+  | RecordType
+  | FnType
+  | UnionType
+  | NamedType
+
+export interface AnyType {
+  kind: 'any'
+}
+
+export interface NilType {
+  kind: 'nil'
+}
+
+export interface PrimType {
+  kind: 'prim'
+  name: 'boolean' | 'number' | 'string'
+}
+
+export interface ArrayType {
+  kind: 'array'
+  element: Type
+}
+
+export interface DictType {
+  kind: 'dict'
+  key: Type
+  value: Type
+}
+
+export interface RecordType {
+  kind: 'record'
+  fields: Map<string, Type>
+}
+
+export interface FnType {
+  kind: 'fn'
+  params: Type[]
+  returns: Type
+}
+
+export interface UnionType {
+  kind: 'union'
+  types: Type[]
+}
+
+export interface NamedType {
+  kind: 'named'
+  name: string
+  /** Filled after alias resolution when the name is a type alias. */
+  resolved?: Type
+}
+
+export const ANY: AnyType = { kind: 'any' }
+export const NIL: NilType = { kind: 'nil' }
+export const NUMBER: PrimType = { kind: 'prim', name: 'number' }
+export const STRING: PrimType = { kind: 'prim', name: 'string' }
+export const BOOLEAN: PrimType = { kind: 'prim', name: 'boolean' }
+
+const PRIMS: Record<string, PrimType> = {
+  number: NUMBER,
+  string: STRING,
+  boolean: BOOLEAN,
+  bool: BOOLEAN,
+}
+
+/** Resolve an AST type annotation into the checker's type model. */
+export function fromTypeAnn(ann: TypeAnn): Type {
+  switch (ann.kind) {
+    case 'named': {
+      const prim = PRIMS[ann.name]
+      if (prim) return prim
+      if (ann.name === 'any') return ANY
+      if (ann.name === 'nil') return NIL
+      return { kind: 'named', name: ann.name }
+    }
+    case 'array':
+      return { kind: 'array', element: fromTypeAnn(ann.element) }
+    case 'dict':
+      return { kind: 'dict', key: fromTypeAnn(ann.key), value: fromTypeAnn(ann.value) }
+    case 'record': {
+      const fields = new Map<string, Type>()
+      for (const field of ann.fields) fields.set(field.name, fromTypeAnn(field.type))
+      return { kind: 'record', fields }
+    }
+    case 'union':
+      return union(ann.types.map(fromTypeAnn))
+    case 'fn':
+      return {
+        kind: 'fn',
+        params: ann.params.map(fromTypeAnn),
+        returns: fromTypeAnn(ann.returns),
+      }
+    case 'optional':
+      return union([fromTypeAnn(ann.type), NIL])
+    default:
+      return ANY
+  }
+}
+
+/** Normalise a union: flatten, drop duplicates, collapse `any`, keep `nil` last. */
+export function union(types: Type[]): Type {
+  const flat: Type[] = []
+  for (const type of types) {
+    if (type.kind === 'union') flat.push(...type.types)
+    else flat.push(type)
+  }
+  const seen = new Set<string>()
+  const out: Type[] = []
+  for (const type of flat) {
+    const key = print(type)
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(type)
+  }
+  if (out.some(type => type.kind === 'any')) return ANY
+  if (out.length === 1) return out[0]
+  const nonNil: Type[] = out.filter(type => type.kind !== 'nil')
+  const nils: Type[] = out.filter(type => type.kind === 'nil')
+  return { kind: 'union', types: [...nonNil, ...nils] }
+}
+
+export function isNil(type: Type): boolean {
+  return type.kind === 'nil'
+}
+
+/** Remove `nil` from a type (used by `if x then` narrowing). */
+export function withoutNil(type: Type): Type {
+  if (type.kind !== 'union') return type.kind === 'nil' ? ANY : type
+  const rest = type.types.filter(item => item.kind !== 'nil')
+  if (!rest.length) return ANY
+  return union(rest)
+}
+
+/** `target` accepts `source`? Structural, with `any` behaving as both directions. */
+export function isAssignable(target: Type, source: Type): boolean {
+  if (target.kind === 'any' || source.kind === 'any') return true
+  if (target.kind === 'named' && target.resolved) return isAssignable(target.resolved, source)
+  if (source.kind === 'named' && source.resolved) return isAssignable(target, source.resolved)
+
+  if (target.kind === 'union') {
+    if (source.kind === 'union') return source.types.every(item => isAssignable(target, item))
+    return target.types.some(item => isAssignable(item, source))
+  }
+  if (source.kind === 'union') return source.types.every(item => isAssignable(target, item))
+
+  if (target.kind !== source.kind) return false
+
+  switch (target.kind) {
+    case 'nil':
+      return true
+    case 'prim':
+      return source.kind === 'prim' && source.name === target.name
+    case 'array':
+      return source.kind === 'array' && isAssignable(target.element, source.element)
+    case 'dict':
+      return source.kind === 'dict'
+        && isAssignable(target.key, source.key)
+        && isAssignable(target.value, source.value)
+    case 'record': {
+      if (source.kind !== 'record') return false
+      for (const [name, type] of target.fields) {
+        const found = source.fields.get(name)
+        if (!found || !isAssignable(type, found)) return false
+      }
+      return true
+    }
+    case 'fn': {
+      if (source.kind !== 'fn' || source.params.length !== target.params.length) return false
+      const paramsOk = target.params.every((type, index) => isAssignable(source.params[index], type))
+      return paramsOk && isAssignable(target.returns, source.returns)
+    }
+    case 'named':
+      return source.kind === 'named' && source.name === target.name
+    default:
+      return false
+  }
+}
+
+/** Human readable type, used in diagnostics. */
+export function print(type: Type): string {
+  switch (type.kind) {
+    case 'any':
+      return 'any'
+    case 'nil':
+      return 'nil'
+    case 'prim':
+      return type.name
+    case 'array':
+      return `[${print(type.element)}]`
+    case 'dict':
+      return `{${print(type.key)}: ${print(type.value)}}`
+    case 'record': {
+      const fields = [...type.fields].map(([name, value]) => `${name}: ${print(value)}`)
+      return `{ ${fields.join(', ')} }`
+    }
+    case 'fn':
+      return `(${type.params.map(print).join(', ')}) -> ${print(type.returns)}`
+    case 'union':
+      return type.types.map(print).join(' | ')
+    case 'named':
+      return type.name
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.