fixtures

9 files changed, 310 insertions, 2 deletions

diff --git a/src/test/fixtures/await.ts b/src/test/fixtures/await.ts
new file mode 100644
index 000000000..802b3b3f0
--- /dev/null
+++ b/src/test/fixtures/await.ts
@@ -0,0 +1 @@
+const init: (VariableDeclaration | AnyExpression) = true;
diff --git a/src/test/fixtures/class-with-property.ts b/src/test/fixtures/class-with-property.ts
new file mode 100644
index 000000000..9c9aee2d4
--- /dev/null
+++ b/src/test/fixtures/class-with-property.ts
@@ -0,0 +1,3 @@
+class Foo {
+  prop: string;
+}
diff --git a/src/test/fixtures/json-parser-in-typescript.js b/src/test/fixtures/json-parser-in-typescript.js
new file mode 100644
index 000000000..b81b6d820
--- /dev/null
+++ b/src/test/fixtures/json-parser-in-typescript.js
@@ -0,0 +1,7 @@
+// {
+//   "name": "Jamie Kyle",
+// } & {
+//   "twitter": "https://twitter.com/buildsghost"
+// }
+export default class Foo {
+}
diff --git a/src/test/fixtures/json-parser-in-typescript.ts b/src/test/fixtures/json-parser-in-typescript.ts
new file mode 100644
index 000000000..8987a5f7f
--- /dev/null
+++ b/src/test/fixtures/json-parser-in-typescript.ts
@@ -0,0 +1,80 @@
+type ParserError<T extends string> = { error: true } & T;
+type EatWhitespace<State extends string> = string extends State
+  ? ParserError<"EatWhitespace got generic string type">
+  : State extends ` ${infer State}` | `\n${infer State}`
+  ? EatWhitespace<State>
+  : State;
+type AddKeyValue<
+  Memo extends Record<string, any>,
+  Key extends string,
+  Value extends any
+> = Memo & { [K in Key]: Value };
+type ParseJsonObject<
+  State extends string,
+  Memo extends Record<string, any> = {}
+> = string extends State
+  ? ParserError<"ParseJsonObject got generic string type">
+  : EatWhitespace<State> extends `}${infer State}`
+  ? [Memo, State]
+  : EatWhitespace<State> extends `"${infer Key}"${infer State}`
+  ? EatWhitespace<State> extends `:${infer State}`
+    ? ParseJsonValue<State> extends [infer Value, `${infer State}`]
+      ? EatWhitespace<State> extends `,${infer State}`
+        ? ParseJsonObject<State, AddKeyValue<Memo, Key, Value>>
+        : EatWhitespace<State> extends `}${infer State}`
+        ? [AddKeyValue<Memo, Key, Value>, State]
+        : ParserError<`ParseJsonObject received unexpected token: ${State}`>
+      : ParserError<`ParseJsonValue returned unexpected value for: ${State}`>
+    : ParserError<`ParseJsonObject received unexpected token: ${State}`>
+  : ParserError<`ParseJsonObject received unexpected token: ${State}`>;
+type ParseJsonArray<State extends string, Memo extends any[] = []> =
+  string extends State
+    ? ParserError<"ParseJsonArray got generic string type">
+    : EatWhitespace<State> extends `]${infer State}`
+    ? [Memo, State]
+    : ParseJsonValue<State> extends [infer Value, `${infer State}`]
+    ? EatWhitespace<State> extends `,${infer State}`
+      ? ParseJsonArray<EatWhitespace<State>, [...Memo, Value]>
+      : EatWhitespace<State> extends `]${infer State}`
+      ? [[...Memo, Value], State]
+      : ParserError<`ParseJsonArray received unexpected token: ${State}`>
+    : ParserError<`ParseJsonValue returned unexpected value for: ${State}`>;
+type ParseJsonValue<State extends string> = string extends State
+  ? ParserError<"ParseJsonValue got generic string type">
+  : EatWhitespace<State> extends `null${infer State}`
+  ? [null, State]
+  : EatWhitespace<State> extends `true${infer State}`
+  ? [true, State]
+  : EatWhitespace<State> extends `false${infer State}`
+  ? [false, State]
+  : EatWhitespace<State> extends `"${infer Value}"${infer State}`
+  ? [Value, State]
+  : EatWhitespace<State> extends `[${infer State}`
+  ? ParseJsonArray<State>
+  : EatWhitespace<State> extends `{${infer State}`
+  ? ParseJsonObject<State>
+  : ParserError<`ParseJsonValue received unexpected token: ${State}`>;
+export type ParseJson<T extends string> = ParseJsonValue<T> extends infer Result
+  ? Result extends [infer Value, string]
+    ? Value
+    : Result extends ParserError<any>
+    ? Result
+    : ParserError<"ParseJsonValue returned unexpected Result">
+  : ParserError<"ParseJsonValue returned uninferrable Result">;
+
+type Person =
+  ParseJson<'{ "name": "Jamie Kyle", "twitter": "https://twitter.com/buildsghost" }'>;
+// {
+//   "name": "Jamie Kyle",
+// } & {
+//   "twitter": "https://twitter.com/buildsghost"
+// }
+
+export default class Foo {
+  person: Person;
+  pooop: Poop;
+}
+export const person: Person = {
+  name: "Jamie Kyle",
+  twitter: "https://twitter.com/buildsghost",
+};
diff --git a/src/test/fixtures/namespaced-validators.ts b/src/test/fixtures/namespaced-validators.ts
new file mode 100644
index 000000000..fcafcb139
--- /dev/null
+++ b/src/test/fixtures/namespaced-validators.ts
@@ -0,0 +1,71 @@
+enum AllTheWays {
+  you = 1,
+  can = "can",
+  enum = 2,
+  really,
+  for,
+  namespace,
+  let,
+  of,
+  const,
+  var,
+  while,
+  true = 8,
+}
+
+enum LogLevel {
+  ERROR,
+  WARN,
+  INFO,
+  DEBUG,
+}
+
+/**
+ * This is equivalent to:
+ * type LogLevelStrings = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
+ */
+type LogLevelStrings = keyof typeof LogLevel;
+
+function printImportant(key: LogLevelStrings, message: string) {
+  const num = LogLevel[key];
+  if (num <= LogLevel.WARN) {
+    console.log("Log level key is:", key);
+    console.log("Log level value is:", num);
+    console.log("Log level message is:", message);
+  }
+}
+printImportant("WARN", "This is a message");
+
+namespace Validation {
+  export interface StringValidator {
+    isAcceptable(s: string): boolean;
+  }
+  const lettersRegexp = /^[A-Za-z]+$/;
+  const numberRegexp = /^[0-9]+$/;
+  export class LettersOnlyValidator implements StringValidator {
+    isAcceptable(s: string) {
+      return lettersRegexp.test(s);
+    }
+  }
+  export class ZipCodeValidator implements StringValidator {
+    isAcceptable(s: string) {
+      return s.length === 5 && numberRegexp.test(s);
+    }
+  }
+}
+// Some samples to try
+let strings = ["Hello", "98052", "101"];
+// Validators to use
+let validators: { [s: string]: Validation.StringValidator } = {};
+validators["ZIP code"] = new Validation.ZipCodeValidator();
+validators["Letters only"] = new Validation.LettersOnlyValidator();
+// Show whether each string passed each validator
+for (let s of strings) {
+  for (let name in validators) {
+    console.log(
+      `"${s}" - ${
+        validators[name].isAcceptable(s) ? "matches" : "does not match"
+      } ${name}`
+    );
+  }
+}
diff --git a/src/test/fixtures/out.esbuild.js b/src/test/fixtures/out.esbuild.js
new file mode 100644
index 000000000..8afef3006
--- /dev/null
+++ b/src/test/fixtures/out.esbuild.js
@@ -0,0 +1,2 @@
+(() => {
+})();
diff --git a/src/test/fixtures/react-context.tsx b/src/test/fixtures/react-context.tsx
new file mode 100644
index 000000000..7a26c02bb
--- /dev/null
+++ b/src/test/fixtures/react-context.tsx
@@ -0,0 +1,8 @@
+import React from "react";
+import type { DocumentProps } from "./internal/types";
+
+export const DocumentContext = React.createContext<DocumentProps>(null as any);
+
+if (process.env.NODE_ENV !== "production") {
+  DocumentContext.displayName = "DocumentContext";
+}
diff --git a/src/test/fixtures/simple-component.tsx b/src/test/fixtures/simple-component.tsx
index 9f4fe729a..ab328e66b 100644
--- a/src/test/fixtures/simple-component.tsx
+++ b/src/test/fixtures/simple-component.tsx
@@ -1,5 +1,3 @@
-import * as React from "react";
-
 type WelcomeProps = {
   greeting?: string;
 };
diff --git a/src/test/fixtures/typescript-is-turing-complete.ts b/src/test/fixtures/typescript-is-turing-complete.ts
new file mode 100644
index 000000000..11f9d5be0
--- /dev/null
+++ b/src/test/fixtures/typescript-is-turing-complete.ts
@@ -0,0 +1,138 @@
+type StringBool = "true" | "false";
+
+interface AnyNumber {
+  prev?: any;
+  isZero: StringBool;
+}
+interface PositiveNumber {
+  prev: any;
+  isZero: "false";
+}
+
+type IsZero<TNumber extends AnyNumber> = TNumber["isZero"];
+type Next<TNumber extends AnyNumber> = { prev: TNumber; isZero: "false" };
+type Prev<TNumber extends PositiveNumber> = TNumber["prev"];
+
+type Add<T1 extends AnyNumber, T2> = {
+  true: T2;
+  false: Next<Add<Prev<T1>, T2>>;
+}[IsZero<T1>];
+
+// Computes T1 * T2
+type Mult<T1 extends AnyNumber, T2 extends AnyNumber> = MultAcc<T1, T2, _0>;
+type MultAcc<T1 extends AnyNumber, T2, TAcc extends AnyNumber> = {
+  true: TAcc;
+  false: MultAcc<Prev<T1>, T2, Add<TAcc, T2>>;
+}[IsZero<T1>];
+
+// Computes max(T1 - T2, 0).
+type Subt<T1 extends AnyNumber, T2 extends AnyNumber> = {
+  true: T1;
+  false: Subt<Prev<T1>, Prev<T2>>;
+}[IsZero<T2>];
+
+interface SubtResult<
+  TIsOverflow extends StringBool,
+  TResult extends AnyNumber
+> {
+  isOverflowing: TIsOverflow;
+  result: TResult;
+}
+
+// Returns a SubtResult that has the result of max(T1 - T2, 0) and indicates whether there was an overflow (T2 > T1).
+type SafeSubt<T1 extends AnyNumber, T2 extends AnyNumber> = {
+  true: SubtResult<"false", T1>;
+  false: {
+    true: SubtResult<"true", T1>;
+    false: SafeSubt<Prev<T1>, Prev<T2>>;
+  }[IsZero<T1>];
+}[IsZero<T2>];
+
+type _0 = { isZero: "true" };
+type _1 = Next<_0>;
+type _2 = Next<_1>;
+type _3 = Next<_2>;
+type _4 = Next<_3>;
+type _5 = Next<_4>;
+type _6 = Next<_5>;
+type _7 = Next<_6>;
+type _8 = Next<_7>;
+type _9 = Next<_8>;
+
+type Digits = {
+  0: _0;
+  1: _1;
+  2: _2;
+  3: _3;
+  4: _4;
+  5: _5;
+  6: _6;
+  7: _7;
+  8: _8;
+  9: _9;
+};
+type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type NumberToType<TNumber extends Digit> = Digits[TNumber]; // I don't know why typescript complains here.
+
+type _10 = Next<_9>;
+type _100 = Mult<_10, _10>;
+
+type Dec2<T2 extends Digit, T1 extends Digit> = Add<
+  Mult<_10, NumberToType<T2>>,
+  NumberToType<T1>
+>;
+
+function forceEquality<T1, T2 extends T1>() {}
+function forceTrue<T extends "true">() {}
+
+//forceTrue<Equals<  Dec2<0,3>,  Subt<Mult<Dec2<2,0>, _3>, Dec2<5,7>>   >>();
+//forceTrue<Equals<  Dec2<0,2>,  Subt<Mult<Dec2<2,0>, _3>, Dec2<5,7>>   >>();
+
+type Mod<TNumber extends AnyNumber, TModNumber extends AnyNumber> = {
+  true: _0;
+  false: Mod2<TNumber, TModNumber, SafeSubt<TNumber, TModNumber>>;
+}[IsZero<TNumber>];
+type Mod2<
+  TNumber extends AnyNumber,
+  TModNumber extends AnyNumber,
+  TSubtResult extends SubtResult<any, any>
+> = {
+  true: TNumber;
+  false: Mod<TSubtResult["result"], TModNumber>;
+}[TSubtResult["isOverflowing"]];
+
+type Equals<TNumber1 extends AnyNumber, TNumber2 extends AnyNumber> = Equals2<
+  TNumber1,
+  TNumber2,
+  SafeSubt<TNumber1, TNumber2>
+>;
+type Equals2<
+  TNumber1 extends AnyNumber,
+  TNumber2 extends AnyNumber,
+  TSubtResult extends SubtResult<any, any>
+> = {
+  true: "false";
+  false: IsZero<TSubtResult["result"]>;
+}[TSubtResult["isOverflowing"]];
+
+type IsPrime<TNumber extends PositiveNumber> = IsPrimeAcc<
+  TNumber,
+  _2,
+  Prev<Prev<TNumber>>
+>;
+
+type IsPrimeAcc<TNumber, TCurrentDivisor, TCounter extends AnyNumber> = {
+  false: {
+    true: "false";
+    false: IsPrimeAcc<TNumber, Next<TCurrentDivisor>, Prev<TCounter>>;
+  }[IsZero<Mod<TNumber, TCurrentDivisor>>];
+  true: "true";
+}[IsZero<TCounter>];
+
+forceTrue<IsPrime<Dec2<1, 1>>>();
+forceTrue<IsPrime<Dec2<1, 2>>>();
+forceTrue<IsPrime<Dec2<1, 3>>>();
+forceTrue<IsPrime<Dec2<1, 4>>>();
+forceTrue<IsPrime<Dec2<1, 5>>>();
+forceTrue<IsPrime<Dec2<1, 6>>>();
+forceTrue<IsPrime<Dec2<1, 7>>>();