Forgot files

Author: Batiste Bieler

docs/TYPESCRIPT_GAP_ANALYSIS.md

@@ -34,6 +34,7 @@ Purpose:
 | Mapped types (`{ [K in keyof T]: T[K] }`) | Done |
 | Utility aliases: `Partial`, `Required`, `Pick`, `Omit` | Done |
 | Conditional types | Done with Blop syntax: `T extends U => X else Y` |
+| Utility alias: `ReturnType<T>` | Done |
 
 ---
 
@@ -51,7 +52,7 @@ Purpose:
 |---|---|
 | Function overloads | Better API typing ergonomics |
 | Template literal types | Stronger string-level typing |
-| Remaining stdlib utility aliases (`ReturnType`, `Parameters`) | Practical TS parity surface |
+| Remaining stdlib utility aliases (`Parameters`) | Practical TS parity surface |
 
 ### Tier 3 — Advanced
 
@@ -70,7 +71,7 @@ Purpose:
 ## Recommended Next Order
 
 1. `infer` keyword
-2. Utility aliases based on conditional types (`ReturnType`, `Parameters`)
+2. Utility alias based on conditional types (`Parameters`)
 3. Function overloads
 4. Template literal types
 
@@ -91,6 +92,7 @@ Purpose:
 - Exhaustiveness tests: `src/tests/typeSystem/exhaustivenessChecking.test.js`
 - Mapped type tests: `src/tests/typeSystem/mappedTypes.test.js`
 - Conditional type tests: `src/tests/typeSystem/conditionalTypes.test.js`
+- ReturnType tests: `src/tests/typeSystem/returnType.test.js`
 - Predicate tests: `src/tests/typeSystem/typePredicates.test.js`
 - Keyof tests: `src/tests/typeSystem/keyofType.test.js`
 - Index signature tests: `src/tests/typeSystem/indexSignatures.test.js`

src/inference/typeSystem.js

@@ -73,6 +73,29 @@ function resolveGenericType(type, aliasMap) {
       return resolvedA;
     }
 
+    // ReturnType<F> — built-in special case: extract function return type
+    if (baseName === 'ReturnType' && type.typeArgs.length >= 1) {
+      const resolvedF = resolveAliasType(resolveGenericType(type.typeArgs[0], aliasMap), aliasMap);
+
+      if (resolvedF instanceof FunctionType) {
+        return resolvedF.returnType;
+      }
+
+      if (resolvedF instanceof UnionType) {
+        const returnTypes = [];
+        for (const member of resolvedF.types) {
+          const resolvedMember = resolveAliasType(resolveGenericType(member, aliasMap), aliasMap);
+          if (!(resolvedMember instanceof FunctionType)) {
+            return NeverType;
+          }
+          returnTypes.push(resolvedMember.returnType);
+        }
+        return createUnion(returnTypes);
+      }
+
+      return NeverType;
+    }
+
     const instantiated = aliasMap.instantiate(baseName, type.typeArgs);
     return instantiated !== undefined ? instantiated : type;
   }

src/tests/typeSystem/conditionalTypes.test.js

@@ -0,0 +1,60 @@
+import { describe, test } from 'vitest';
+import { compileSource } from '../../compile.js';
+import { dedent, expectCompiles, expectCompilationError } from '../testHelpers.js';
+
+function compile(src) {
+  return compileSource(dedent(src), 'test.blop', true);
+}
+
+describe('conditional types', () => {
+  test('generic conditional resolves true branch', () => {
+    expectCompiles(`
+      type IsString<T> = T extends string => true else false
+      x: IsString<string> = true
+    `);
+  });
+
+  test('generic conditional resolves false branch', () => {
+    expectCompiles(`
+      type IsString<T> = T extends string => true else false
+      x: IsString<number> = false
+    `);
+  });
+
+  test('mismatched branch assignment errors', () => {
+    expectCompilationError(
+      `
+        type IsString<T> = T extends string => true else false
+        x: IsString<number> = true
+      `,
+      'Cannot assign true to IsString<number>'
+    );
+  });
+
+  test('conditional can return never in false branch', () => {
+    expectCompiles(`
+      type OnlyString<T> = T extends string => T else never
+      x: OnlyString<string> = 'ok'
+    `);
+  });
+
+  test('conditional never false branch rejects values', () => {
+    expectCompilationError(
+      `
+        type OnlyString<T> = T extends string => T else never
+        x: OnlyString<number> = 1
+      `,
+      'Cannot assign 1 to OnlyString<number>'
+    );
+  });
+
+  test('conditional can be used inside mapped utility composition', () => {
+    const result = compile(`
+      type IsString<T> = T extends string => true else false
+      x = 1
+    `);
+    if (!result.success) {
+      throw new Error(`Expected no errors but got: ${JSON.stringify(result.errors)}`);
+    }
+  });
+});

src/tests/typeSystem/exhaustivenessChecking.test.js

@@ -0,0 +1,45 @@
+import { describe, test } from 'vitest';
+import { compileSource } from '../../compile.js';
+import { dedent, expectCompilationError } from '../testHelpers.js';
+
+function compile(src) {
+  return compileSource(dedent(src), 'test.blop', true);
+}
+
+function expectNoErrors(src) {
+  const result = compile(src);
+  if (!result.success) {
+    throw new Error(`Expected no errors but got: ${JSON.stringify(result.errors)}`);
+  }
+}
+
+describe('exhaustiveness checking for if/elseif chains', () => {
+  test('flags use after exhaustive early-return chain on literal union', () => {
+    expectCompilationError(
+      `
+        def parseKind(kind: 'a' | 'b'): string {
+          if kind == 'a' {
+            return 'A'
+          } elseif kind == 'b' {
+            return 'B'
+          }
+          return kind
+        }
+      `,
+      "has been narrowed to 'never'"
+    );
+  });
+
+  test('does not flag when chain is not exhaustive', () => {
+    expectNoErrors(`
+      def parseKind(kind: 'a' | 'b' | 'c'): string {
+        if kind == 'a' {
+          return 'A'
+        } elseif kind == 'b' {
+          return 'B'
+        }
+        return 'C'
+      }
+    `);
+  });
+});

src/tests/typeSystem/returnType.test.js

@@ -0,0 +1,40 @@
+import { describe, test } from 'vitest';
+import { expectCompiles, expectCompilationError, dedent } from '../testHelpers.js';
+
+describe('ReturnType<T>', () => {
+  test('extracts return type from function type alias', () => {
+    expectCompiles(dedent(`
+      type Fn = (name: string) => number
+      type R = ReturnType<Fn>
+      x: R = 42
+    `));
+  });
+
+  test('works with inline function type argument', () => {
+    expectCompiles(dedent(`
+      type R = ReturnType<(a: number) => string>
+      x: R = 'ok'
+    `));
+  });
+
+  test('supports union of function types', () => {
+    expectCompiles(dedent(`
+      type F1 = (x: string) => number
+      type F2 = (x: number) => string
+      type F = F1 | F2
+      type R = ReturnType<F>
+      a: R = 1
+      b: R = 'ok'
+    `));
+  });
+
+  test('non-function argument falls back to never', () => {
+    expectCompilationError(
+      dedent(`
+        type R = ReturnType<string>
+        x: R = 1
+      `),
+      'Cannot assign 1 to R'
+    );
+  });
+});