diff --git a/.github/workflows/performance-and-size.yml b/.github/workflows/performance-and-size.yml
index 9ce0f5b3..2b88e15d 100644
--- a/.github/workflows/performance-and-size.yml
+++ b/.github/workflows/performance-and-size.yml
@@ -29,18 +29,6 @@ jobs:
with:
packages: hyperfine
- # For displaying line count in file
- - name: Download scc
- run: |
- mkdir scc
- cd scc
- gh release download v3.1.0 -R boyter/scc -p '*Linux_x86_64.tar.gz' -O scc.tar.gz
- tar -xf scc.tar.gz
- chmod +x scc
- pwd >> $GITHUB_PATH
- env:
- GH_TOKEN: ${{ github.token }}
-
- name: Build Ezno
run: cargo build --release
env:
@@ -52,8 +40,6 @@ jobs:
# Generate a file which contains everything that Ezno currently implements
cargo run -p ezno-parser --example code_blocks_to_script ./checker/specification/specification.md --comment-headers --out ./demo.tsx
- LINES_OF_CODE=$(scc -c --no-cocomo -f json demo.tsx | jq ".[0].Code")
-
echo "### Checking
\`\`\`shell
$(hyperfine -i './target/release/ezno check demo.tsx')
@@ -62,10 +48,8 @@ jobs:
echo "
Input
+ > Code generated from specification.md. this is not meant to accurately represent a program but instead give an idea for how it scales across all the type checking features
\`\`\`tsx
- // $LINES_OF_CODE lines of TypeScript generated from specification.md
- // this is not meant to accurately represent a program but instead give an idea
- // for how it scales across all the type checking features
$(cat ./demo.tsx)
\`\`\`
@@ -73,22 +57,65 @@ jobs:
echo "::info::Wrote code to summary"
+ command_output=$(./target/release/ezno check demo.tsx --timings --max-diagnostics all 2>&1 || true)
+ diagnostics=""; statistics=""; found_splitter=false;
+
+ while IFS= read -r line; do
+ if [[ "$line" == "---"* ]]; then found_splitter=true;
+ elif [[ "$found_splitter" == false ]]; then diagnostics+="$line"$'\n';
+ else statistics+="$line"$'\n'; fi
+ done <<< "$command_output"
+
echo "
Diagnostics
-
+
\`\`\`
- $(./target/release/ezno check demo.tsx --timings --max-diagnostics all 2>&1 || true)
+ $diagnostics
+ \`\`\`
+
+
+
+ Statistics
+
+ \`\`\`
+ $statistics
\`\`\`
" >> $GITHUB_STEP_SUMMARY
+ - name: Run checker performance w/staging
+ shell: bash
+ if: github.ref_name != 'main'
+ run: |
+ echo "::group::Running all"
+
+ cat ./checker/specification/specification.md ./checker/specification/staging.md > all.md
+ cargo run -p ezno-parser --example code_blocks_to_script all.md --comment-headers --out ./all.tsx
+
+ ./target/release/ezno check all.tsx --timings || true
+ echo "::endgroup::"
+
+ - name: Run checker performance on large file
+ shell: bash
+ run: |
+ echo "::group::Running large"
+
+ cat ./checker/specification/specification.md > main.md
+ cargo run -p ezno-parser --example code_blocks_to_script all.md --comment-headers --out ./code.tsx
+ for i in {1..10}; do
+ cat ./code.tsx >> large.tsx
+ done
+
+ ./target/release/ezno check large.tsx --timings --max-diagnostics 0 || true
+ echo "::endgroup::"
+
- name: Run parser, minfier/stringer performance
shell: bash
run: |
strings=(
"https://esm.sh/v128/react-dom@18.2.0/es2022/react-dom.mjs"
- "https://esm.sh/v135/typescript@5.3.3/es2022/typescript.mjs"
)
+ # Currently broken "https://esm.sh/v135/typescript@5.3.3/es2022/typescript.mjs"
for url in "${strings[@]}"; do
curl -sS $url > input.js
diff --git a/.gitignore b/.gitignore
index 4ba56a16..0dcdeb02 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ node_modules
/TODO.txt
checker/specification/Cargo.lock
checker/definitions/es5.d.ts
+.grit
\ No newline at end of file
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 56803504..baddb3f1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -25,7 +25,7 @@ Now in the `ezno` directory, `cargo run` should show the CLI.
You can run just the checker with
```shell
-cargo run -p ezno-checker --example run-checker path/to/file.ts
+cargo run -p ezno-checker --example run_checker path/to/file.ts
```
> [!TIP]
diff --git a/Cargo.lock b/Cargo.lock
index 38bb9718..c11fef7b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -308,6 +308,7 @@ dependencies = [
"ezno-parser",
"iterator-endiate",
"levenshtein",
+ "match_deref",
"ordered-float",
"path-absolutize",
"serde",
diff --git a/Cargo.toml b/Cargo.toml
index bec01db9..7e2350c8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -79,16 +79,20 @@ js-sys = "0.3"
tsify = "0.4.5"
[workspace.lints.clippy]
-all = "deny"
-pedantic = "deny"
+all = { level = "deny", priority = -1 }
+pedantic = { level = "deny", priority = -1 }
cast_precision_loss = "warn"
cast_possible_truncation = "warn"
cast_sign_loss = "warn"
default_trait_access = "allow"
missing_errors_doc = "allow"
missing_panics_doc = "allow"
-implicit_hasher = "allow"
module_name_repetitions = "allow"
too_many_lines = "allow"
new_without_default = "allow"
result_unit_err = "allow"
+thread_local_initializer_can_be_made_const = "allow"
+implicit_hasher = "allow"
+
+[profile.dev]
+debug = false
diff --git a/README.md b/README.md
index 32b4c50b..1a174c96 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
A JavaScript compiler and TypeScript checker written in Rust with a focus on static analysis and runtime performance.
> [!IMPORTANT]
-> Ezno is in active development and **does not currently support enough features to check existing projects**. Check out the [getting started guide](./checker/documentation/getting-started.md) for experimenting with what it [currently supports](./checker/specification/specification.md).
+> Ezno is in active development and **does not currently support enough features to check existing projects** (see [blocking issues](https://github.com/kaleidawave/ezno/labels/blocking)). Check out the [getting started guide](./checker/documentation/getting-started.md) for experimenting with what it [currently supports](./checker/specification/specification.md).
@@ -21,7 +21,7 @@ What Ezno is not
- Be on parity with TSC or 1:1, it has some different behaviors **but** should work in existing projects using TSC
- Faster as a means to serve large codebases. Cut out bloat and complex code first!
- Smarter as a means to allow more *dynamic patterns*. Keep things simple!
-- A binary executable compiler. It takes in JavaScript (or a TypeScript or Ezno superset) and does similar processes to traditional compilers, but at the end emits JavaScript. However, in the future, it _could_ generate a lower level format using its event (side-effect) representation.
+- A binary executable compiler. It takes in JavaScript (or a TypeScript or Ezno superset) and does similar processes to traditional compilers, but at the end emits JavaScript. However, in the future, it *could* generate a lower level format using its event (side-effect) representation.
Read more about Ezno (in chronological order)
- [Introducing Ezno](https://kaleidawave.github.io/posts/introducing-ezno/)
@@ -40,7 +40,6 @@ This project is a workspace consisting of a few crates:
-
## Help contribute
Check out [good first issues]((https://github.com/kaleidawave/ezno/issues?q=is%3Aopen+label%3Agood-first-issue%2Cfeedback-needed)) and comment on discussions! Feel free to ask questions on parts of the code of the checking implementation.
diff --git a/checker/Cargo.toml b/checker/Cargo.toml
index 87e52760..6800f69d 100644
--- a/checker/Cargo.toml
+++ b/checker/Cargo.toml
@@ -48,10 +48,12 @@ tsify = "0.4.5"
# TODO needs unfixed change in source-map
wasm-bindgen = "=0.2.89"
-
[dependencies.parser]
path = "../parser"
optional = true
version = "0.1.5"
features = ["extras"]
package = "ezno-parser"
+
+[dev-dependencies]
+match_deref = "0.1.1"
diff --git a/checker/definitions/internal.ts.d.bin b/checker/definitions/internal.ts.d.bin
index 8cfb2cd1..69dd2cab 100644
Binary files a/checker/definitions/internal.ts.d.bin and b/checker/definitions/internal.ts.d.bin differ
diff --git a/checker/definitions/overrides.d.ts b/checker/definitions/overrides.d.ts
index 83d4736d..abb1be71 100644
--- a/checker/definitions/overrides.d.ts
+++ b/checker/definitions/overrides.d.ts
@@ -1,10 +1,7 @@
-@Constant
-declare function debug_type_independent(t: any): void;
-
// Eventually this will be merged with existing TS es5.d.ts files but for now is the standalone see #121
interface ImportEnv {
- [key: string]: string | undefined;
+ [key: string]: string;
}
interface ImportMeta {
@@ -14,7 +11,7 @@ interface ImportMeta {
}
declare class Array {
- [index: number]: T | undefined;
+ [index: number]: T;
length: number;
@@ -33,8 +30,7 @@ declare class Array {
return undefined
} else {
const value = this[--this.length];
- // TODO this currently breaks value?
- // delete this[this.length];
+ delete this[this.length];
return value
}
}
@@ -101,35 +97,6 @@ declare class Array {
return false
}
- // fill(value: T, start: number = 0, end = this.length): this {
- // // TODO
- // return this
- // }
-
- // reduce(cb: (acc: U, t: T, i?: number) => U, initial?: U): U {
- // const { length } = this;
- // let acc = initial ?? this[0];
- // let i: number = typeof initial === "undefined" ? 1 : 0;;
- // while (i < length) {
- // const value = this[i];
- // acc = cb(acc, value, i++);
- // }
- // return acc;
- // }
-
- // includes(searchElement: T, fromIndex?: number): boolean {
- // const { length } = this;
- // // TODO this is currently broken
- // let i: number = fromIndex ?? 0;
- // while (i < length) {
- // const value = this[i++];
- // if (value === searchElement) {
- // return true
- // }
- // }
- // return false
- // }
-
join(joiner: string = ","): string {
const { length } = this;
let i: number = 1;
@@ -173,22 +140,28 @@ declare class Math {
static sqrt(x: number): number;
@Constant
static cbrt(x: number): number;
+ @Constant
+ static log(x: number): number;
// TODO newer method
@Constant
static trunc(x: number): number;
static PI: 3.141592653589793
+ static E: 2.718281828459045
+
+ @InputOutput
+ static random(): number;
}
@Primitive("string")
declare class String {
- [index: number]: string | undefined;
+ [index: number]: string;
@Constant
- toUpperCase(): string;
+ toUpperCase(this: string): string;
@Constant
- toLowerCase(): string;
+ toLowerCase(this: string): string;
get length(): number;
@@ -294,11 +267,11 @@ declare class SyntaxError extends Error {
declare class JSON {
// TODO any temp
- @Constant("json:parse", SyntaxError)
+ @Constant("JSON:parse", SyntaxError)
static parse(input: string): any;
// TODO any temp
- @Constant("json:stringify")
+ @Constant("JSON:stringify")
static stringify(input: any): string;
}
@@ -308,7 +281,7 @@ declare class Function {
declare class Symbols {
// TODO temp
- iterator: 199
+ static iterator: unique symbol "iterator"
}
declare class Proxy {
@@ -316,6 +289,18 @@ declare class Proxy {
constructor(obj: any, cb: any);
}
+// Copied from `es5.d.ts`. Could this be an or
+// TODO string keys temp because parser broke
+interface PropertyDescriptor {
+ value?: any;
+ ["get" ? (): any;
+ ["set" ? (v: any): void;
+
+ writable?: boolean;
+ configurable?: boolean;
+ enumerable?: boolean;
+}
+
declare class Object {
@Constant
static setPrototypeOf(on: object, to: object): object;
@@ -323,11 +308,19 @@ declare class Object {
@Constant
static getPrototypeOf(on: object): object | null;
- // static create(prototype: object): object {
- // const n = {};
- // Object.setProtoTypeOf(n, prototype);
- // return n
- // }
+ @Constant
+ static freeze(on: object): object;
+
+ @Constant
+ static isFrozen(on: object): boolean;
+
+ // TODO defineProperties via body (not constant)
+ @Constant
+ static defineProperty(on: object, property: string, discriminator: PropertyDescriptor): boolean;
+
+ // TODO getOwnPropertyDescriptors via body (not constant)
+ @Constant
+ static getOwnPropertyDescriptor(on: object, property: string): PropertyDescriptor;
static keys(on: { [s: string]: any }): Array {
const keys: Array = [];
@@ -353,6 +346,14 @@ declare class Object {
return entries
}
+ // TODO multiple arguments
+ static assign(target: object, source: object): object {
+ for (const key in source) {
+ target[key] = source[key]
+ }
+ return target
+ }
+
// static fromEntries(iterator: any): object {
// const obj = {};
// for (const item of iterator) {
@@ -415,6 +416,8 @@ declare function debug_context(): void;
declare function context_id(): void;
@Constant
declare function context_id_chain(): void;
+@Constant
+declare function debug_type_independent(t: any): void;
// A function, as it should be!
@Constant
diff --git a/checker/definitions/simple.d.ts b/checker/definitions/simple.d.ts
index deb1120b..d5814b3d 100644
--- a/checker/definitions/simple.d.ts
+++ b/checker/definitions/simple.d.ts
@@ -5,6 +5,8 @@ declare function print_type(...args: Array): void
@Constant
declare function debug_type(...args: Array): void
@Constant
+declare function debug_type_independent(...args: Array): void
+@Constant
declare function print_and_debug_type(...args: Array): void
@Constant
declare function print_constraint(t: any): void
@@ -38,7 +40,7 @@ declare function satisfies(t: T): T
declare function compile_type_to_object(): any
interface ImportEnv {
- [key: string]: string | undefined;
+ [key: string]: string;
}
interface ImportMeta {
@@ -48,13 +50,14 @@ interface ImportMeta {
}
declare class Array {
- [index: number]: T | undefined;
+ [index: number]: T;
length: number;
push(item: T) {
- this[this.length] = item;
- return ++this.length
+ let at = this.length++;
+ this[at] = item;
+ return at + 1
}
pop(): T | undefined {
@@ -62,62 +65,83 @@ declare class Array {
return undefined
} else {
const value = this[--this.length];
- // TODO this breaks things
- // delete this[this.length];
- // debug_type_rust_independent(value);
+ delete this[this.length];
return value
}
}
- // // TODO this argument
+ // map(cb: (t: T, i?: number) => U): Array {
+ // TODO this argument
map(cb: (t: T, i?: number) => U): Array {
const { length } = this, mapped: Array = [];
let i: number = 0;
while (i < length) {
- const value = this[i];
- mapped.push(cb(value, i++))
+ const value = this?.[i];
+ const newValue = cb(value, i++);
+ mapped.push(newValue)
}
return mapped;
}
+ // copy(): Array {
+ // const { length } = this, mapped: Array = [];
+ // let i: number = 0;
+ // while (i < length) {
+ // mapped.push(this?.[i])
+ // }
+ // return mapped;
+ // }
+
+ // // // TODO any is debatable
+ // filter(cb: (t: T, i?: number) => any): Array {
+ // const { length } = this, filtered: Array = [];
+ // let i: number = 0;
+ // while (i < length) {
+ // const value = this[i];
+ // if (cb(value, i++)) {
+ // filtered.push(value)
+ // }
+ // }
+ // return filtered;
+ // }
+
// // TODO any is debatable
- filter(cb: (t: T, i?: number) => any): Array {
- const { length } = this, filtered: Array = [];
- let i: number = 0;
- while (i < length) {
- const value = this[i];
- if (cb(value, i++)) {
- filtered.push(value)
- }
- }
- return filtered;
- }
+ // find(cb: (t: T, i?: number) => any): T | undefined {
+ // const { length } = this;
+ // let i: number = 0;
+ // while (i < length) {
+ // const value = this[i];
+ // if (cb(value, i++)) {
+ // return value
+ // }
+ // }
+ // }
- // TODO any is debatable
- find(cb: (t: T, i?: number) => any): T | undefined {
- const { length } = this;
- let i: number = 0;
- while (i < length) {
- const value = this[i];
- if (cb(value, i++)) {
- return value
- }
- }
- }
+ // // TODO any is debatable
+ // every(cb: (t: T, i?: number) => any): boolean {
+ // const { length } = this;
+ // let i: number = 0;
+ // while (i < length) {
+ // const value = this[i];
+ // if (!cb(value, i++)) {
+ // return false
+ // }
+ // }
+ // // Vacuous truth
+ // return true
+ // }
- // TODO any is debatable
- every(cb: (t: T, i?: number) => any): boolean {
- const { length } = this;
- let i: number = 0;
- while (i < length) {
- const value = this[i];
- if (!cb(value, i++)) {
- return false
- }
- }
- // Vacuous truth
- return true
- }
+ // includes(looking_for: T): boolean {
+ // const { length } = this;
+ // let i: number = 0;
+ // while (i < length) {
+ // const value = this[i++];
+ // if (value === looking_for) {
+ // return true
+ // }
+ // }
+ // return false
+ // }
// some(cb: (t: T, i?: number) => any): boolean {
// const { length } = this;
@@ -131,35 +155,66 @@ declare class Array {
// return false
// }
- join(joiner: string = ","): string {
- const { length } = this;
- let i: number = 1;
- if (length === 0) {
- return ""
- }
- let s: string = "" + this[0];
- while (i < length) {
- s += joiner;
- s += this[i++];
- }
- return s
- }
+ // join(joiner: string = ","): string {
+ // const { length } = this;
+ // let i: number = 1;
+ // if (length === 0) {
+ // return ""
+ // }
+ // let s: string = "" + this[0];
+ // while (i < length) {
+ // s += joiner;
+ // s += this[i++];
+ // }
+ // return s
+ // }
- at(index: number) {
- if (index < 0) {
- return this[index + this.length]
- } else {
- return this[index]
- }
+ // at(index: number) {
+ // if (index < 0) {
+ // return this[index + this.length]
+ // } else {
+ // return this[index]
+ // }
+ // }
+}
+
+declare class Map {
+ #keys: Array;
+ #values: Array;
+
+ constructor() {
+ this.#keys = []
+ this.#values = []
}
+
+ // get(key: K): V | undefined {
+ // // return this.#keys;
+ // const { length } = this.#keys;
+ // for (let i = 0; i < length; i++) {
+ // const s = length - 1 - i;
+ // if (this.#keys[s] === key) {
+ // return this.#values[s]
+ // }
+ // }
+ // }
+
+ // set(key: K, value: V) {
+ // this.#keys.push(key);
+ // this.#values.push(value);
+ // }
}
type Record = { [P in K]: T }
-declare class Map {
- #keys: Array = [];
- #value: Array = [];
-}
+/**
+ * Exclude from T those types that are assignable to U
+ */
+type Exclude = T extends U ? never : T;
+
+/**
+ * Extract from T those types that are assignable to U
+ */
+type Extract = T extends U ? T : never;
declare class Math {
@Constant
@@ -174,22 +229,28 @@ declare class Math {
static sqrt(x: number): number;
@Constant
static cbrt(x: number): number;
+ @Constant
+ static log(x: number): number;
// TODO newer method
@Constant
static trunc(x: number): number;
static PI: 3.141592653589793
+ static E: 2.718281828459045
+
+ @InputOutput
+ static random(): number;
}
@Primitive("string")
declare class String {
- [index: number]: string | undefined;
+ [index: number]: string;
@Constant
- toUpperCase(): string;
+ toUpperCase(this: string): string;
@Constant
- toLowerCase(): string;
+ toLowerCase(this: string): string;
get length(): number;
@@ -233,16 +294,18 @@ declare class Error {
}
declare class SyntaxError extends Error {
- constructor() { super("syntax error") }
+ constructor() {
+ super("syntax error");
+ }
}
declare class JSON {
// TODO any temp
- @Constant("json:parse", SyntaxError)
+ @Constant("JSON:parse", SyntaxError)
static parse(input: string): any;
// TODO any temp
- @Constant("json:stringify")
+ @Constant("JSON:stringify")
static stringify(input: any): string;
}
@@ -250,9 +313,9 @@ declare class Function {
bind(this_ty: any): Function;
}
-declare class Symbols {
+declare class Symbol {
// TODO temp
- iterator: 199
+ static iterator: unique symbol "iterator"
}
declare class Proxy {
@@ -260,6 +323,18 @@ declare class Proxy {
constructor(obj: any, cb: any);
}
+// Copied from `es5.d.ts`. Could this be an or
+// TODO string keys temp because parser broke
+interface PropertyDescriptor {
+ value?: any;
+ ["get" ? (): any;
+ ["set" ? (v: any): void;
+
+ writable?: boolean;
+ configurable?: boolean;
+ enumerable?: boolean;
+}
+
declare class Object {
@Constant
static setPrototypeOf(on: object, to: object): object;
@@ -267,46 +342,37 @@ declare class Object {
@Constant
static getPrototypeOf(on: object): object | null;
+ @Constant
+ static freeze(on: object): object;
+
+ @Constant
+ static isFrozen(on: object): boolean;
+
+ // TODO defineProperties via body (not constant)
+ @Constant
+ static defineProperty(on: object, property: string, discriminator: PropertyDescriptor): boolean;
+
+ // TODO getOwnPropertyDescriptors via body (not constant)
+ @Constant
+ static getOwnPropertyDescriptor(on: object, property: string): PropertyDescriptor;
+
// static create(prototype: object): object {
// const n = {};
// Object.setProtoTypeOf(n, prototype);
// return n
// }
+}
- static keys(on: { [s: string]: any }): Array {
- const keys: Array = [];
- for (const key in on) {
- keys.push(key);
- }
- return keys
- }
-
- static values(on: { [s: string]: any }): Array {
- const values: Array = [];
- for (const key in on) {
- values.push(on[key]);
- }
- return values
- }
-
- static entries(on: { [s: string]: any }): Array<[string, any]> {
- const entries: Array<[string, any]> = [];
- for (const key in on) {
- entries.push([key, on[key]]);
- }
- return entries
- }
-
- // static fromEntries(iterator: any): object {
- // const obj = {};
- // for (const item of iterator) {
- // const { 0: key, 1: value } = item;
- // obj[key] = value;
- // }
- // return obj
- // }
+declare class RegExp {
+ @Constant("RegExp:constructor")
+ constructor(s: string)
}
+// WIP
+// interface SymbolImplementations {
+// [Symbol.iterator]: () => { next(): { value: any, done: boolean } }
+// }
+
// TODO wip
declare function JSXH(tag: string, attributes: any, children?: any) {
return { tag, attributes, children }
diff --git a/checker/documentation/checking.md b/checker/documentation/checking.md
index 3e8ac1c8..45f18617 100644
--- a/checker/documentation/checking.md
+++ b/checker/documentation/checking.md
@@ -23,12 +23,20 @@ Rather than checking whether types are subtypes of some base type, these are con
## Checking a program
Starts with a list of statements.
-Before any of the statements are checked, they are first *hoisted*.
+Before any of the statements and declarations are checked, they are first *hoisted*.
+
+After that the checker performs synthesis and checking. It only visits expressions once, the binding happens at the same time as checking.
### Hoisting
Both types and variables can be used before their declaration position in the source. Before checking statements, a group of passes 'lifts' certain information.
-There are three stages to hoisting.
+There are three stages to hoisting an item
+
+- Declaring an item
+- Registering it
+- Finishing it?
+
+There are four stages to
(1) Firstly
- Interface and type alias **names** are declared
diff --git a/checker/examples/calculate_subtypes.rs b/checker/examples/calculate_subtypes.rs
index 6ef83f4d..66270eef 100644
--- a/checker/examples/calculate_subtypes.rs
+++ b/checker/examples/calculate_subtypes.rs
@@ -16,7 +16,7 @@ fn main() {
let mut types = TypeStore::default();
basics(&mut environment, &mut types);
- contributions(&mut environment, &mut types)
+ contributions(&mut environment, &mut types);
}
fn basics(environment: &mut Environment, types: &mut TypeStore) {
@@ -29,22 +29,22 @@ fn basics(environment: &mut Environment, types: &mut TypeStore) {
{
let result = type_is_subtype_object(TypeId::NUMBER_TYPE, five, environment, types);
- eprintln!("number :> 5 {result:?}")
+ eprintln!("number :> 5 {result:?}");
}
{
let result =
type_is_subtype_object(TypeId::NUMBER_TYPE, TypeId::STRING_TYPE, environment, types);
- eprintln!("number :> string {result:?}")
+ eprintln!("number :> string {result:?}");
}
{
let result =
type_is_subtype_object(string_or_number, TypeId::STRING_TYPE, environment, types);
- eprintln!("string | number :> string {result:?}")
+ eprintln!("string | number :> string {result:?}");
}
- eprintln!("--------------\n")
+ eprintln!("--------------\n");
}
fn contributions(environment: &mut Environment, types: &mut TypeStore) {
@@ -60,7 +60,6 @@ fn contributions(environment: &mut Environment, types: &mut TypeStore) {
Publicity::Public,
inner.clone(),
PropertyValue::Value(generic_parameter.type_id),
- false,
source_map::SpanWithSource::NULL,
);
@@ -77,11 +76,11 @@ fn contributions(environment: &mut Environment, types: &mut TypeStore) {
&mut environment.info,
);
basis.append(
- environment,
Publicity::Public,
inner,
PropertyValue::Value(five),
source_map::SpanWithSource::NULL,
+ &mut environment.info,
);
basis.build_object()
};
@@ -96,7 +95,7 @@ fn contributions(environment: &mut Environment, types: &mut TypeStore) {
others: SubTypingOptions::default(),
object_constraints: None,
};
- let result = type_is_subtype(parameter, five_obj, &mut state, &environment, &types);
+ let result = type_is_subtype(parameter, five_obj, &mut state, environment, types);
let contributions = state.contributions.as_ref().unwrap();
diff --git a/checker/examples/generate_cache.rs b/checker/examples/generate_cache.rs
index 27f4bba0..d7ccc711 100644
--- a/checker/examples/generate_cache.rs
+++ b/checker/examples/generate_cache.rs
@@ -17,5 +17,5 @@ fn main() {
let cache = generate_cache::<_, EznoParser>(PathBuf::from(input).as_path(), &reader, ());
write(output, cache).unwrap();
- eprintln!("Cache generated 🏧💵✅")
+ eprintln!("Cache generated 🏧💵✅");
}
diff --git a/checker/examples/run-checker.rs b/checker/examples/run_checker.rs
similarity index 79%
rename from checker/examples/run-checker.rs
rename to checker/examples/run_checker.rs
index 89e816a1..eee0dc63 100644
--- a/checker/examples/run-checker.rs
+++ b/checker/examples/run_checker.rs
@@ -1,7 +1,7 @@
#[cfg(feature = "ezno-parser")]
fn main() {
use ezno_checker::{check_project, synthesis, Diagnostic, TypeCheckOptions};
- use std::{collections::HashSet, fs, path::Path, time::Instant};
+ use std::{fs, path::Path, time::Instant};
let default_path = Path::new("private").join("tocheck").join("aaa.tsx");
let simple_dts_path = Path::new("checker").join("definitions").join("simple.d.ts");
@@ -12,34 +12,43 @@ fn main() {
let path = args
.first()
.and_then(|arg| (!arg.starts_with("--")).then_some(arg))
- .map(Path::new)
- .unwrap_or(default_path.as_path());
+ .map_or(default_path.as_path(), Path::new);
let use_simple = args.iter().any(|item| item == "--simple-dts");
let no_cache = args.iter().any(|item| item == "--no-cache");
let debug_types = args.iter().any(|item| item == "--debug-types");
+ let no_lib = args.iter().any(|item| item == "--no-lib");
+ let debug_dts = args.iter().any(|item| item == "--debug-dts");
let now = Instant::now();
let resolver = |path: &std::path::Path| fs::read(path).ok();
- let definition_file = if use_simple {
- simple_dts_path.to_path_buf()
- } else if no_cache {
- overrides_dts_path.to_path_buf()
+ let type_definition_files = if no_lib {
+ Vec::new()
} else {
- ezno_checker::INTERNAL_DEFINITION_FILE_PATH.into()
+ let definition_file = if use_simple {
+ simple_dts_path.clone()
+ } else if no_cache {
+ overrides_dts_path.clone()
+ } else {
+ ezno_checker::INTERNAL_DEFINITION_FILE_PATH.into()
+ };
+ vec![definition_file]
};
- let type_definition_files = HashSet::from_iter([definition_file]);
+
+ let entry_points = vec![path.to_path_buf()];
let options = TypeCheckOptions {
debug_types,
record_all_assignments_and_reads: true,
+ max_inline_count: 600,
+ debug_dts,
..Default::default()
};
let result = check_project::<_, synthesis::EznoParser>(
- vec![path.to_path_buf()],
+ entry_points,
type_definition_files,
resolver,
options,
@@ -49,7 +58,8 @@ fn main() {
if args.iter().any(|arg| arg == "--types") {
eprintln!("Types:");
- for (type_id, item) in result.types.into_vec_temp() {
+ let types = result.types.into_vec_temp();
+ for (type_id, item) in &types[types.len().saturating_sub(60)..] {
eprintln!("\t{type_id:?}: {item:?}");
}
}
diff --git a/checker/specification/README.md b/checker/specification/README.md
index a2482f1b..17f841f6 100644
--- a/checker/specification/README.md
+++ b/checker/specification/README.md
@@ -9,6 +9,10 @@ These can all be ran as tests using the markdown to Rust test code transpiler in
- Comments can be in block quotes to explain additional details in the tests
- Sections are at level three headings (`###`), tests are at level four headings (`####`), the tested code goes a code block with the language tag `ts` and errors in a bullet list after in order
- Blocks can be split into files with a `// in file.ts` comment, below which all code is in the `file.ts` file. Default is `main.tsx`
+- **Code in blocks is indented with tabs not spaces**
---
Other tests unrelated to specific checking features can be found in `checker/tests`
+
+> [!IMPORTANT]
+> Any tests that throw or produce unreachables must be contained as it breaks the total concatenation.
diff --git a/checker/specification/build.rs b/checker/specification/build.rs
index b860a076..e31236a4 100644
--- a/checker/specification/build.rs
+++ b/checker/specification/build.rs
@@ -134,7 +134,8 @@ fn markdown_lines_append_test_to_rust(
fn heading_to_rust_identifier(heading: &str) -> String {
heading
- .replace([' ', '-', '/', '&', '.', '+'], "_")
- .replace(['*', '\'', '`', '"', '!', '(', ')', ','], "")
+ .replace("...", "")
+ .replace([' ', '-', '/', '.', '+'], "_")
+ .replace(['*', '\'', '`', '"', '&', '!', '(', ')', ','], "")
.to_lowercase()
}
diff --git a/checker/specification/specification.md b/checker/specification/specification.md
index f7838ac9..fc791100 100644
--- a/checker/specification/specification.md
+++ b/checker/specification/specification.md
@@ -46,10 +46,11 @@ a satisfies number
#### Variable references does not exist
```ts
-const a = c
+const exists = 2;
+nexists
```
-- Could not find variable 'c' in scope. Did you mean a?
+- Could not find variable 'nexists' in scope
#### Assigning before declaration
@@ -107,6 +108,34 @@ b satisfies string;
- Expected string, found undefined
+#### TDZ in statements
+
+```ts
+let first = second;
+let second = 2;
+```
+
+- Variable 'second' used before declaration
+
+#### `var` can be reregistered
+
+```ts
+{
+ // Fine
+ var x = 2;
+ x satisfies 2;
+ var x = 3;
+ x satisfies 3;
+}
+
+{
+ let b = 2;
+ var b = 2;
+}
+```
+
+- Cannot redeclare variable 'b'
+
### Properties
#### Property exists
@@ -117,7 +146,7 @@ const a = my_obj.a
const b = my_obj.b
```
-- No property 'b' on { a: 3 }. Did you mean a?
+- No property 'b' on { a: 3 }
#### Reading property (via accessor)
@@ -149,7 +178,7 @@ const my_obj: { b: 3 } = { b: 4 }
#### Getters
```ts
-let global = 0;
+let global: number = 0;
const object = {
// This getter has an impure side effect
get value() {
@@ -185,7 +214,7 @@ object.value satisfies string
let a = 2;
const obj = {
x: 5,
- set value(v) {
+ set value(this: { x: number }, v) {
this.x = v;
}
}
@@ -200,13 +229,15 @@ obj.x satisfies 5;
```ts
const obj = {
- set value(v: string) { }
+ set value(v: string) { }
}
obj.value = 5;
```
-- Type 5 does not meet property constraint string
+> TODO could the error be better?
+
+- Argument of type 5 is not assignable to parameter of type string (in setter)
#### Setter side effect
@@ -253,9 +284,9 @@ obj2.a satisfies boolean;
#### Set property with key
```ts
-const obj = { a: 2 }
+const obj: { a?: number, b?: number } = { a: 2 }
-function setProperty(key: string, value) {
+function setProperty(key: "a" | "b", value: number) {
obj[key] = value;
}
@@ -273,7 +304,7 @@ delete x.b;
const b = x.b;
```
-- No property 'b' on { a: 2 }. Did you mean a?
+- No property 'b' on { a: 2 }
#### `Object.keys`, `Object.values`, `Object.entries`
@@ -291,11 +322,11 @@ Object.entries({ a: 1, b: 2 }) satisfies boolean;
declare let condition: boolean;
const obj = {
- foo: 1,
- ...(condition ? {
- bar: 2,
- non_existent: 3,
- } : {}),
+ foo: 1,
+ ...(condition ? {
+ bar: 2,
+ non_existent: 3,
+ } : {}),
};
obj.foo satisfies number;
@@ -304,7 +335,305 @@ obj.bar satisfies string;
- Expected string, found 2 | undefined
-### Excess property
+#### And on properties
+
+> Note that it keeps it as a `and`. It does not join the properties into a single typ
+
+```ts
+declare type U = { a: 2 } & { b: 3 }
+declare let x: U;
+x.b satisfies 3;
+
+({ a: 2, b: 3 } satisfies U);
+({ b: 3 } satisfies U);
+```
+
+- Expected U, found { b: 3 }
+
+#### Properties on or
+
+```ts
+declare let key: "a" | "b";
+
+const object = { a: "apple", b: "banana" };
+object[key] satisfies boolean;
+```
+
+- Expected boolean, found "apple" | "banana"
+
+#### Properties on big or
+
+> TODO this creates a fat or type
+
+```ts
+const array = [1, 2, 3];
+array[Math.random()] satisfies string;
+```
+
+- Expected string, found 1 | 2 | 3 | undefined
+
+#### Properties matched against continous type become conditional
+
+> I think this is TSC behavior under indexed access
+
+```ts
+declare let strings: { [a: string]: number };
+declare let record: Record;
+declare let d: { [a: "a" | "b"]: number };
+
+strings.a satisfies number | undefined;
+record.a satisfies boolean;
+d.a satisfies number;
+```
+
+- Expected boolean, found number | undefined
+
+#### Un-delete-able property
+
+> TODO in a function as well
+
+```ts
+const x: { a?: number } = { a: 4 };
+// Fine
+delete x.a;
+
+const y: { a: number } = { a: 4 };
+// Bad
+delete y.a;
+
+const z = {};
+Object.defineProperty(z, "a", { value: 4 });
+delete z.a;
+```
+
+- Cannot delete from object constrained to { a: number }
+- Cannot delete from non-configurable property
+
+#### Order of numerical properties
+
+> TODO test could be better using `for in` or `Object.keys` etc
+
+```ts
+let x = {}; x.something = null; x[4] = null; x["eight"] = null; x["2"] = null;
+x satisfies string;
+```
+
+- Expected string, found { 2: null, 4: null, something: null, eight: null }
+
+#### Order of properties after assignment
+
+> TODO this is because setting properties are simply appended. There are two straightforward fixes, but I am unsure which one is better...
+
+```ts
+const obj = { a: 1, b: 2 };
+obj.a = 2; obj.c = 6; obj.b = 4;
+obj satisfies boolean;
+```
+
+- Expected boolean, found { a: 2, b: 4, c: 6 }
+
+#### Assigning to getter
+
+```ts
+const obj = { get prop() { return 2 } };
+obj.prop = "hi";
+obj.prop satisfies 2;
+```
+
+- Cannot write to property 'prop' as it is a getter
+
+#### Assinging to non existent property
+
+> Allowing this could break objects passed to functions
+
+```ts
+const obj = { prop: 1 };
+// Fine
+obj.non_existent = 6;
+
+function func(param: { prop: number }) {
+ param.notProp = 5;
+}
+```
+
+- Cannot write to non-existent property 'notProp'
+
+#### Function and class name
+
+> TODO should also check that it is readonly
+
+```ts
+function a() { }
+class B { }
+let c = class { }
+
+a.name satisfies "a"
+B.name satisfies "B"
+c.name satisfies "sea"
+```
+
+- Expected "sea", found "c"
+
+#### Getters AND setter
+
+> This involves property lookup skipping setter and getters
+
+```ts
+let global: number = 0;
+const object = {
+ get value() {
+ return global
+ },
+ set value(newValue: number) {
+ global = newValue;
+ }
+}
+
+object.value satisfies string;
+object.value = 10;
+object.value satisfies 10;
+global satisfies 10
+```
+
+- Expected string, found 0
+
+#### Getters AND setter can be type via `Object.defineProperty`
+
+> TODO parameter checking as well
+
+```ts
+function func(get: () => number) {
+ const obj = {};
+ Object.defineProperty(obj, "value", { get });
+ obj.value satisfies string
+}
+```
+
+- Expected string, found number
+
+#### `enumerable` in for in
+
+```ts
+const obj = { n: 1, b: 2 };
+Object.defineProperty(obj, "c", { value: 3, enumerable: false });
+Object.defineProperty(obj, "d", { value: 4, enumerable: true });
+
+let keys: string = "";
+for (const key in obj) {
+ keys += key;
+}
+keys satisfies boolean
+```
+
+- Expected boolean, found "nbd"
+
+#### `Object.freeze`
+
+> TODO seal & preventExtensions
+
+```ts
+const obj = {}
+let result = Object.freeze(obj);
+(obj === result) satisfies true;
+obj.property = 2;
+Object.isFrozen(obj) satisfies true;
+```
+
+> TODO maybe error should say that whole object is frozen
+
+- Cannot write to property 'property'
+
+#### `Object.defineProperty` writable
+
+> TODO defineProperties
+
+```ts
+const obj = {};
+Object.defineProperty(obj, 'property', {
+ value: 42,
+ writable: false,
+});
+obj.property satisfies string;
+obj.property = 70;
+```
+
+- Expected string, found 42
+- Cannot write to property 'property'
+
+#### Descriptor carries across assignments
+
+> TODO defineProperties
+
+```ts
+const obj = {};
+Object.defineProperty(obj, 'property', {
+ value: 42,
+ enumerable: false,
+ // needed as all properties default to false
+ writable: true,
+});
+obj.property = 70;
+Object.getOwnPropertyDescriptor(obj, 'property') satisfies string;
+```
+
+- Expected string, found { value: 70, writable: true, enumerable: false, configurable: false }
+
+#### `Object.defineProperty` getter and setter
+
+> TODO setter
+
+```ts
+const obj = {};
+let b = 0;
+Object.defineProperty(obj, 'property', {
+ get: () => b,
+});
+obj.property satisfies 0;
+b++;
+obj.property satisfies string;
+```
+
+- Expected string, found 1
+
+#### `Object.defineProperty` configurable
+
+```ts
+const obj = {};
+Object.defineProperty(obj, 'property', { value: 6 });
+Object.defineProperty(obj, 'property', { value: "hi" });
+```
+
+- Property 'property' not configurable
+
+#### `Object.getOwnPropertyDescriptor`
+
+> TODO getOwnPropertyDescriptors
+
+```ts
+const obj = { a: "something" };
+Object.defineProperty(obj, 'b', { value: 42 });
+
+Object.getOwnPropertyDescriptor(obj, 'a') satisfies string;
+Object.getOwnPropertyDescriptor(obj, 'b').writable satisfies false;
+```
+
+> Order is also important
+
+- Expected string, found { value: "something", writable: true, enumerable: true, configurable: true }
+
+#### `Object.assign`
+
+> TODO multiple RHS
+
+```ts
+const obj = { a: 1 };
+Object.assign(obj, { b: 2, c: 3 });
+obj satisfies string;
+```
+
+- Expected string, found { a: 1, b: 2, c: 3 }
+s
+### Excess properties
> The following work through the same mechanism as forward inference
> Thanks to pull request: #139
@@ -327,9 +656,14 @@ interface MyObject { property: string }
function process(param: MyObject) {}
process({ property: "hello", another: 2 });
+
+function func(a: T) { }
+
+func({ property: "hello", "something else": 2 })
```
- 'another' is not a property of MyObject
+- 'something else' is not a property of MyObject
#### Excess property at return type
@@ -349,21 +683,21 @@ function returnNewObject(): MyObject {
type MyObject = { foo: number; bar?: number };
const b: MyObject = {
- foo: 1,
- ...{
- bar: 2,
- invalid: 3,
- },
+ foo: 1,
+ ...{
+ bar: 2,
+ invalid: 3,
+ },
};
declare let condition: boolean;
const c: MyObject = {
- foo: 1,
- ...(condition ? {
- bar: 2,
- non_existent: 3,
- } : {}),
+ foo: 1,
+ ...(condition ? {
+ bar: 2,
+ non_existent: 3,
+ } : {}),
};
```
@@ -494,8 +828,8 @@ function func(a: number) {
```ts
function outer(a: number) {
- function inner(b: string = Math.floor(a)) {
- }
+ function inner(b: string = Math.floor(a)) {
+ }
}
```
@@ -511,30 +845,6 @@ function func(): string {
- Cannot return 2 because the function is expected to return string
-#### *Inferred* return type
-
-```ts
-function func() {
- return 2
-}
-func satisfies () => string
-```
-
-- Expected () => string, found () => 2
-
-#### Set property on dependent observed
-
-```ts
-function add_property(obj: { prop: number }) {
- obj.prop = 2;
- (obj.prop satisfies 4);
-}
-```
-
-> Not number
-
-- Expected 4, found 2
-
#### Type checking basic function types
```ts
@@ -549,18 +859,6 @@ func satisfies (a: number, b: number) => boolean;
- Expected (a: string, b: number) => string, found (a: string, b: number) => boolean
- Expected (a: number, b: number) => boolean, found (a: string, b: number) => boolean
-#### Function that throws returns never
-
-```ts
-function myThrow() {
- throw "err!"
-}
-
-myThrow satisfies string;
-```
-
-- Expected string, found () => never
-
#### Return generics mismatch
```ts
@@ -611,7 +909,7 @@ function createObject2(a: T, b: U): { a: U, b: U } {
const x: (a: string) => number = a => a.to;
```
-- No property 'to' on string.
+- No property 'to' on string
#### Expected argument from parameter declaration
@@ -623,7 +921,7 @@ function map(a: (a: number) => number) {}
map(a => a.t)
```
-- No property 't' on number.
+- No property 't' on number
#### Assignment to parameter
@@ -678,11 +976,11 @@ myFunction({ a: 6 }) satisfies string;
```ts
function getNumber1(): number {
- return 4
+ return 4
}
function getNumber2() {
- return 6
+ return 6
}
getNumber1 satisfies () => 4;
@@ -701,20 +999,106 @@ getNumber2() satisfies 6;
```ts
function x() {
- getString(3)
+ getString(3)
}
function y() {
- getString("something") satisfies string;
+ getString("something") satisfies string;
}
function getString(param: string): string {
- return "hi"
+ return "hi"
}
```
- Argument of type 3 is not assignable to parameter of type string
+### Inferred return types
+
+#### Simple
+
+```ts
+function id(a: number) {
+ return a
+}
+
+function simple() {
+ return "hello world"
+}
+
+id satisfies (n: number) => number;
+simple satisfies () => number;
+```
+
+- Expected () => number, found () => "hello world"
+
+#### Conditional
+
+```ts
+function func(condition: T) {
+ if (condition) {
+ return 4
+ } else {
+ return 3
+ }
+}
+
+func satisfies string;
+```
+
+> There are some issues around printing here, when to include the generic etc
+
+- Expected string, found \(condition: T) => T ? 4 : 3
+
+#### Early return
+
+```ts
+function func(value: number) {
+ if (value === 3) {
+ return "is three"
+ }
+ console.log("hi")
+ return "another"
+}
+
+loop satisfies (a: number) => "is three" | "another";
+
+function loop(value: number) {
+ for (let i = 0; i < 10; i++) {
+ if (value === i) {
+ return "something"
+ }
+ }
+ return "another"
+}
+
+loop satisfies (a: number) => "something" | "another";
+
+function sometimes(a: boolean) {
+ if (a) {
+ return "sometimes"
+ }
+}
+
+sometimes satisfies (a: boolean) => string;
+```
+
+- Expected (a: boolean) => string, found (a: boolean) => "sometimes" | undefined
+
+#### `throw` in body
+
+```ts
+function throwSomething() {
+ throw "to implement!"
+}
+
+throwSomething satisfies string;
+```
+
+- Expected string, found () => never
+
+> #TODO try-catch, Promise
+
### Function calling
#### Argument type against parameter
@@ -913,13 +1297,13 @@ const m = new MyClass();
```ts
function myRestFunction(...r: string[]) {
- return r[0] + r[1]
+ return r
}
myRestFunction("hello ", "world") satisfies number;
```
-- Expected number, found "hello world"
+- Expected number, found ["hello ", "world"]
#### Default parameter
@@ -938,11 +1322,11 @@ withDefault(3) satisfies 3;
```ts
let b: number = 0
-function doThing(a = (b += 2)) {
+function doThing(a: number = (b += 2)) {
return a
}
-doThing("hello");
+doThing(7);
b satisfies 0;
doThing();
b satisfies 1;
@@ -956,7 +1340,7 @@ b satisfies 1;
```ts
function optionally(p?: number) {
- p satisfies string;
+ p satisfies string;
}
```
@@ -966,7 +1350,7 @@ function optionally(p?: number) {
```ts
function optionally(p?: number) {
- return p
+ return p
}
// Fine
@@ -978,23 +1362,10 @@ optionally("hello world");
- Argument of type "hello world" is not assignable to parameter of type number | undefined
-#### Tagged template literal
-
-```ts
-function myTag(static_parts: Array, name: string) {
- return static_parts[0] + name
-}
-
-const name = "Ben";
-myTag`${name}Hello ` satisfies "Hi Ben"
-```
-
-- Expected "Hi Ben", found "Hello Ben"
-
#### Default parameter side effect on parameter
```ts
-function doThing(a, b = (a += 2)) {
+function doThing(a: number, b: number = (a += 2)) {
return a
}
@@ -1027,6 +1398,64 @@ myTag`Count is ${"not a number!!"}`;
- Argument of type \"not a number!!\" is not assignable to parameter of type number (in template literal)
+#### Generics on dependent type
+
+> Weird annotation here is to work around [#165](https://github.com/kaleidawave/ezno/issues/165)
+
+```ts
+function createNew(cb: { f(t: T): { a: T }}["f"]) {
+ return cb(4)
+}
+
+createNew satisfies string;
+```
+
+- Expected string, found (cb: \(t: T) => { a: T }) => { a: 4 }
+
+#### Builder pattern
+
+> Testing for `this` returning
+
+```ts
+class StringBuilder {
+ s: string = ""
+
+ append(s: string) {
+ this.s += s;
+ return this
+ }
+
+ finish() {
+ return this.s
+ }
+}
+
+(new StringBuilder).append("Hello ").append("Ben").finish() satisfies number
+```
+
+- Expected number, found "Hello Ben"
+
+#### Dependent operations
+
+```ts
+function isFive(a: number): boolean {
+ return a === 5
+}
+
+isFive(5) satisfies true;
+isFive(6) satisfies string;
+
+function hasPropertyX(obj: object): boolean {
+ return "x" in obj;
+}
+
+hasPropertyX({ a: 2 }) satisfies false;
+hasPropertyX({ x: 5 }) satisfies number;
+```
+
+- Expected string, found false
+- Expected number, found true
+
### Effects
> Side effects of functions. Registered internally as `Event`s
@@ -1130,6 +1559,20 @@ let x: number = 5;
> Not shown in the example but thanks to [#69](https://github.com/kaleidawave/ezno/pull/69) for adding the position of the error
+#### TDZ errors through nested getter
+
+```ts
+function func(obj: { prop: number }) {
+ return obj.prop
+}
+
+func({ get prop() { return b } });
+
+let b: number = 0;
+```
+
+- Variable 'b' used before declaration
+
#### Assignment to union
> Solves the common subtyping issue between read and write properties
@@ -1151,7 +1594,7 @@ setAtoString({ a: 6 });
setAtoString(myObject);
```
-- Invalid assignment to parameter
+- Invalid assignment through parameter
> Error message could be better. Full diagnostic contains labels with more information
> `readA` is allowed, which is disallowed in Hegel, but here is allowed to preserve TSC compatibility (and because how structural subtyping is implemented)
@@ -1201,6 +1644,118 @@ const c = a;
- Expected false, found true
- Expected string, found false
+#### Unconditional throw warning
+
+```ts
+function safeDivide(num: number, denom: number) {
+ if (denom === 0) {
+ throw new Error("Cannot divide by zero");
+ }
+ return num / denom
+}
+
+function func() {
+ safeDivide(8, 4) satisfies 2;
+ // ahh
+ safeDivide(10, 0);
+}
+```
+
+- Conditional '[Error] { message: \"Cannot divide by zero\" }' was thrown in function
+
+#### Unreachable statement
+
+```ts
+function throwGreeting() {
+ throw "Hello";
+ return "Unreachable!"
+}
+
+function doSomething() {
+ throwGreeting()
+ const unreachable = 2;
+}
+```
+
+> One is for `return 5` the other is for `const x = 2;`
+
+- Unreachable statement
+- Unreachable statement
+
+#### `throw` short-circuit
+
+```ts
+let x: number = 2;
+
+function func(cb: () => void) {
+ try {
+ cb();
+ x = 10;
+ return "not-thrown"
+ } catch {
+ return "thrown"
+ }
+}
+
+func(() => { throw "error" }) satisfies "thrown";
+x satisfies string;
+```
+
+- Expected string, found 2
+
+#### `delete` as an effect
+
+```ts
+function dewete(param: { prop?: string }) {
+ const { prop } = param;
+ delete param.prop;
+ return prop
+}
+
+const obj = { prop: "hi" };
+dewete(obj);
+
+obj.prop;
+```
+
+> This error *should* be from the last statement
+
+- No property 'prop' on {}
+
+#### Optional effect key
+
+```ts
+let i: number = 0;
+({ a: true})?.[i++, "a"] satisfies true;
+i satisfies 1;
+
+null?.[i++, "a"];
+i satisfies string;
+```
+
+- Expression is always false
+- Expression is always true
+- Expected string, found 1
+
+#### Effects across functions
+
+```ts
+let value: number = 2;
+function a() { value = 8; }
+function b() { a() }
+
+let func = () => {};
+
+function c() { b() }
+function d(newCb: () => void, then: () => void) { func = newCb; then() }
+
+value satisfies 2;
+d(a, c);
+value satisfies boolean;
+```
+
+- Expected boolean, found 8
+
### Closures
#### Reading variable
@@ -1268,6 +1823,46 @@ value.getValue() satisfies 6
- Expected 6, found 10
+#### Class constructors
+
+```ts
+function func(a: number, b: number) {
+ return class {
+ value: number;
+
+ constructor() {
+ this.value = a;
+ }
+
+ plusB() {
+ return this.value + b
+ }
+ }
+}
+
+const c1 = new (func(1, 2));
+c1.plusB() satisfies 3;
+
+const c2 = new (func(6, 8));
+c2.plusB() satisfies string;
+```
+
+- Expected string, found 14
+
+#### Getters closures
+
+```ts
+function Closure(n: string) {
+ return { get value() { return n }, set value(newValue: string) { n = newValue; } };
+}
+
+let b = Closure("hi");
+b.value = "something";
+b.value satisfies number;
+```
+
+- Expected number, found "something"
+
### Control flow
#### Resolving conditional
@@ -1363,9 +1958,9 @@ b satisfies string;
let i = 0;
declare let b: boolean;
if (b) {
- i = 1
+ i = 1
} else {
- i = 2
+ i = 2
}
i satisfies string;
@@ -1379,10 +1974,10 @@ i satisfies string;
declare let string: string;
function stringIsHi(s: string) {
- if (s === "hi") {
- return true
- }
- return false
+ if (s === "hi") {
+ return true
+ }
+ return false
}
stringIsHi(string) satisfies number;
@@ -1395,8 +1990,7 @@ stringIsHi(string) satisfies number;
#### While loop unrolling
```ts
-let a = 1;
-let i = 0;
+let a: number = 1, i: number = 0;
while (i < 5) {
a *= 2;
i++;
@@ -1410,8 +2004,7 @@ a satisfies 8;
#### While loop event in the condition
```ts
-let a = 1;
-let i = 0;
+let a: number = 1, i: number = 0;
while (i++ < 5) {
a *= 2;
}
@@ -1424,7 +2017,7 @@ a satisfies 8;
#### Do while loop
```ts
-let a = 0;
+let a: number = 0;
do {
a++
} while (a < 3)
@@ -1497,8 +2090,7 @@ loop(10, "!") satisfies number;
#### Break in a while loop
```ts
-let a = 2;
-let i = 0;
+let a: number = 2, i: number = 0;
while (i++ < 10) {
a *= 2;
if (a > 5) {
@@ -1516,8 +2108,7 @@ a satisfies 2;
> With the continue the update to `a` only happens on even runs (5 times)
```ts
-let a = 2;
-let i = 0;
+let a: number = 2, i: number = 0;
while (i++ < 10) {
if (i % 2) {
continue;
@@ -1601,7 +2192,7 @@ console.log("Error caught!")
try {
throw 3
} catch (err: string) {
- console.log(err)
+ console.log(err)
}
console.log("Error caught!")
@@ -1613,11 +2204,11 @@ console.log("Error caught!")
```ts
function exceptionToResult(cb: () => number) {
- try {
- return cb()
- } catch (e) {
- return e
- }
+ try {
+ return cb()
+ } catch (e) {
+ return e
+ }
}
exceptionToResult(() => 6) satisfies 6;
@@ -1631,11 +2222,11 @@ console.log("Error caught!")
```ts
function exceptionToResult(cb: () => number) {
- try {
- cb()
- } catch (e: number) {
- return e
- }
+ try {
+ cb()
+ } catch (e: number) {
+ return e
+ }
}
exceptionToResult(() => { throw "not a number" });
@@ -1648,17 +2239,58 @@ console.log("Error caught!")
```ts
function exceptionToResult(s: string) {
- try {
- return JSON.parse(s)
- } catch (e: number) {
- return e
- }
+ try {
+ return JSON.parse(s)
+ } catch (e: number) {
+ return e
+ }
}
console.log("Error caught!")
```
- Cannot catch type number because the try block throws SyntaxError
+#### Conditional throw
+
+> This emits a warning if a throw was created in a conditional branch
+
+```ts
+// no complex numbers :(
+function checkedLn(x: number) {
+ if (x > 0) {
+ return Math.log(x)
+ } else {
+ throw new Error("Cannot log")
+ }
+}
+
+// Fine
+try { checkedLn(Math.E ** 3) satisfies 3 } catch {}
+// Will throw
+try { checkedLn(-5) } catch {}
+```
+
+- Conditional '[Error] { message: \"Cannot log\" }' was thrown in function
+
+#### Throw through internal callback
+
+```ts
+try {
+ [1, 2, 3].map((x: number) => {
+ if (x === 2) {
+ throw "error"
+ }
+ });
+ console.log("unreachable")
+} catch (e) {
+ e satisfies number;
+}
+```
+
+- Conditional '"error"' was thrown in function
+- Unreachable statement
+- Expected number, found "error"
+
### Collections
> Some of these are built of exiting features.
@@ -1667,9 +2299,9 @@ console.log("Error caught!")
#### Array push
```ts
-const x = [1]
-x.push("hi")
-x[1] satisfies 3
+const x = [1];
+x.push("hi");
+x[1] satisfies 3;
x.length satisfies 4;
```
@@ -1695,18 +2327,31 @@ x.push("hi");
- Argument of type \"hi\" is not assignable to parameter of type number
-#### `map` and `filter`
+#### Array map
> TODO other arguments (index and `this`)
```ts
[6, 8, 10].map(x => x + 1) satisfies [7, 8, 11];
-
-[1, 2, 3].filter(x => x % 2 === 0) satisfies [2];
```
- Expected [7, 8, 11], found [7, 9, 11]
+#### Mutation
+
+> This is part of [assignment mismatch](https://github.com/kaleidawave/ezno/issues/18)
+
+```ts
+function fakeRead(a: Array) {
+ a.push(2)
+}
+
+const array1: Array = []
+fakeRead(array1)
+```
+
+- Invalid assignment through parameter
+
### Statements, declarations and expressions
> Some of these are part of synthesis, rather than checking
@@ -1856,7 +2501,7 @@ y.not_a_key
```
- Expected 3, found 7
-- No property 'not_a_key' on { ezno: 7 }.
+- No property 'not_a_key' on { ezno: 7 }
#### Shorthand object literal
@@ -1925,15 +2570,34 @@ type X = { a: string }
- Type { b: "NaN" } is not assignable to type X
-#### TDZ in statements
+#### As casts
+
+> Disabled normally, allowed for these tests. Provides TSC compatibility and because narrowing not implemented (including secret feature)
```ts
-let first = second;
+declare let global: any;
-let second = 2;
+5 as boolean;
+global satisfies boolean;
+(global as string) satisfies number;
```
-- Variable 'second' used before declaration
+- Cannot cast 5 to boolean
+- Expected boolean, found any
+- Expected number, found string
+
+#### Non-null assertions
+
+> TODO this currently only works on conditionals
+
+```ts
+declare const global: { property?: string };
+
+global.property satisfies string | undefined;
+global.property! satisfies number;
+```
+
+- Expected number, found string
#### `typeof` operator
@@ -1968,16 +2632,16 @@ s satisfies number;
```ts
const o = { a: 1, b: { c: 3 } };
-let a, b, c;
+let a, b, d;
({
- c = o.a++,
- b: { c: b = 7 },
- a,
+ d = o.a++,
+ b: { c: b = 7 },
+ a,
} = o);
a satisfies string;
b satisfies boolean;
-c satisfies 3;
+d satisfies 3;
```
- Expected string, found 2
@@ -1986,7 +2650,7 @@ c satisfies 3;
#### `import.meta`
-> Unfortunately because of bundling `url` and `resolve` cannot have known results so just `string`.
+> Unfortunately because of bundling `url` and `resolve` cannot have known results so just `string`
```ts
import.meta.url satisfies number;
@@ -2054,9 +2718,9 @@ x.value satisfies string
```ts
class X {
- method() {
- return this;
- }
+ method() {
+ return this;
+ }
}
const { method } = new X();
@@ -2178,15 +2842,26 @@ class X { }
- Variable 'X' used before declaration
+#### Called without new
+
+> Declared same as `let` and `const`
+
+```ts
+class X { }
+const x = X();
+```
+
+- Class constructor must be called with new
+
#### Class type `extends`
```ts
class BaseClass {
- b: boolean = false
+ b: boolean = false
}
class Class extends BaseClass {
- a: number = 2
+ a: number = 2
}
new Class().b satisfies 5
@@ -2198,11 +2873,11 @@ new Class().b satisfies 5
```ts
class X {
- static x = 2;
+ static x = 2;
- static {
- const property: 4 = ++this.x;
- }
+ static {
+ const property: 4 = ++this.x;
+ }
}
X.x satisfies 3;
@@ -2214,19 +2889,19 @@ X.x satisfies 3;
```ts
function doThingWithClass(instance: Class) {
- instance.prop satisfies string;
- instance.parent_prop satisfies boolean;
- instance.method(4);
+ instance.prop satisfies string;
+ instance.parent_prop satisfies boolean;
+ instance.method(4);
}
class BaseClass {
- parent_prop: number
+ parent_prop: number
}
class Class extends BaseClass {
- prop: number
+ prop: number
- method(s: string) {}
+ method(s: string) {}
}
```
@@ -2238,16 +2913,16 @@ class Class extends BaseClass {
```ts
function doThingWithClass(instance: Class) {
- instance.a satisfies number;
- instance.b satisfies string;
+ instance.a satisfies number;
+ instance.b satisfies string;
}
class BaseClass {
- b: boolean
+ b: boolean
}
class Class extends BaseClass {
- a: number
+ a: number
}
```
@@ -2258,16 +2933,16 @@ class Class extends BaseClass {
```ts
let b: number = 0;
class Y {
- constructor(a) {
- this.a = a;
- b++;
- }
+ constructor(a) {
+ this.a = a;
+ b++;
+ }
}
class X extends Y {
- constructor(a) {
- super(a);
- }
+ constructor(a) {
+ super(a);
+ }
}
const x = new X("hi");
@@ -2300,7 +2975,7 @@ type X = number;
const a: Y = 2;
```
-- Cannot find type Y. Did you mean T, U or X?
+- Could not find type 'Y'
#### Type shadowing
@@ -2348,14 +3023,16 @@ const b: X = 2;
#### Property on an or type
```ts
-function getProp(obj: { prop: 3 } | { prop: 2 }) {
+function getProp(obj: { prop: 3, prop2: 6 } | { prop: 2 }) {
+ obj.prop2;
return obj.prop
}
getProp satisfies string
```
-- Expected string, found (obj: { prop: 3 } | { prop: 2 }) => 3 | 2
+- No property 'prop2' on { prop: 3, prop2: 6 } | { prop: 2 }
+- Expected string, found (obj: { prop: 3, prop2: 6 } | { prop: 2 }) => 3 | 2
#### Generic extends
@@ -2384,10 +3061,23 @@ const y: (a: number | string) => string = (p: number) => "hi"
> I think reasons contains more information
+#### Function parameter excess allowed
+
+```ts
+// Perfectly fine
+const x: (a: number, b: string) => string = (p: number) => "hi"
+// Bad
+const y: (a: string) => string = (p: number, q: string) => "hi"
+```
+
+- Type (p: number, q: string) => "hi" is not assignable to type (a: string) => string
+
+> I think reasons contains more information
+
#### Function return type subtyping
```ts
-const x: (a: number) => number = p => 4
+const x: (a: number) => number = p => 4;
const y: (a: number) => number = p => "a number"
```
@@ -2468,22 +3158,6 @@ getSecondCharacter("string") satisfies "b";
- Expected boolean, found (s: string) => string | undefined
- Expected "b", found "t"
-#### As casts
-
-> Disabled normally, allowed for these tests. Provides TSC compatibility and because narrowing not implemented (including secret feature)
-
-```ts
-declare let global: any;
-
-5 as boolean;
-global satisfies boolean;
-(global as string) satisfies number;
-```
-
-- Cannot cast 5 to boolean
-- Expected boolean, found any
-- Expected number, found string
-
#### Symmetric or
```ts
@@ -2531,13 +3205,13 @@ function get(obj: {a: 2} | { b: 3 }) {
> `Cannot read property "a" from { b: 3 }`
-- No property 'a' on { a: 2 } | { b: 3 }.
+- No property 'a' on { a: 2 } | { b: 3 }
#### Optional interface member
```ts
interface Optional {
- a?: "hi"
+ a?: "hi"
}
const op1: Optional = {}
@@ -2556,19 +3230,43 @@ type Y = string & number;
- No intersection between types 2 and "hi"
- No intersection between types string and number
+#### Cyclic type alias
+
+```ts
+type Node = { parent: Node, value: T } | null;
+
+null satisfies Node;
+({ parent: { parent: { parent: null, value: 2 }, value: 6 }, value: 2 } satisfies Node);
+({ parent: { parent: { parent: null, value: "hi" }, value: 6 }, value: "hi" } satisfies Node);
+```
+
+- Expected { parent: Node\, value: string } | null, found { parent: { parent: { parent: null, value: "hi" }, value: 6 }, value: "hi" }
+
+#### Cyclic type alias check
+
+```ts
+type X = Y;
+type Y = X;
+
+// test usage doesn't blow up subtyping
+const x: X = 2;
+```
+
+- Circular type reference
+
#### Interface extends
```ts
interface X {
- a: string
+ a: string
}
interface Y {
- b: string
+ b: string
}
interface Z extends X, Y {
- c: string
+ c: string
}
({ a: "", b: "", c: "hello" }) satisfies Z;
@@ -2579,6 +3277,18 @@ interface Z extends X, Y {
- Expected Z, found { a: "", b: 4, c: "hello" }
- Expected Z, found { c: "hi" }
+#### `never` subtyping
+
+```ts
+function getSpecialNumber(): number {
+ throw "to implement!"
+}
+
+getSpecialNumber satisfies string;
+```
+
+- Expected string, found () => number
+
#### Specialisation of return for declare functions
```ts
@@ -2632,14 +3342,14 @@ func() satisfies boolean;
```ts
type ElementOf = T extends Array ? U : never;
-declare let y: ElementOf>;
-declare let z: ElementOf | string>;
+declare let elementOfNumber: ElementOf>;
+declare let elementOfNumberOrString: ElementOf<"not array" | Array>;
-y satisfies number;
-z satisfies string;
+elementOfNumber satisfies number;
+elementOfNumberOrString satisfies string;
declare let n: never;
-n satisfies ElementOf;
+n satisfies ElementOf<"not array">;
```
- Expected string, found number
@@ -2648,13 +3358,11 @@ n satisfies ElementOf;
```ts
interface X {
- a: string,
- b: string
+ a: string,
+ b: string
}
-"a" satisfies keyof X;
-"b" satisfies keyof X;
-"c" satisfies keyof X;
+"a" satisfies keyof X; "b" satisfies keyof X; "c" satisfies keyof X;
```
- Expected keyof X, found "c"
@@ -2673,11 +3381,67 @@ const second: Introduction = "Hi Ben";
#### Assigning to types as keys
```ts
-const x: { [s: string]: number } = { a: 1, b: 2, c: 3 }
-const y: { [s: string]: boolean } = { a: 1, b: 2, c: 3 };
+const obj = { a: 1, b: 2, c: 3 };
+obj satisfies { [s: string]: number };
+obj satisfies { [s: string]: boolean };
+```
+
+- Expected { [string]: boolean }, found { a: 1, b: 2, c: 3 }
+
+#### String slice matching pattern
+
+```ts
+type GetPrefix = S extends `${infer T} ${End}` ? T : false;
+
+4 satisfies GetPrefix<"Hello Ben", "Ben">;
+```
+
+- Expected "Hello", found 4
+
+#### `infer ... extends ...`
+
+```ts
+type X = T extends { a: infer I extends string } ? I : string;
+
+declare let a: X<{ a: 4 }>;
+declare let b: X<{ a: "hello" }>;
+
+a satisfies number;
+b satisfies "hello";
+```
+
+- Expected number, found string
+
+#### TSC string intrinsics
+
+```ts
+const a: Uppercase<"something" |"hi"> = "HI";
+const b: Uppercase = "hi"
+```
+
+- Type \"hi\" is not assignable to type Uppercase\
+
+#### `NoInfer`
+
+```ts
+declare function func(a: T, b: NoInfer): T;
+
+func("hi", "hello") satisfies number;
+```
+
+> but not `| "hello"` !!!
+
+- Expected number, found "hi"
+
+#### Subtyping edge cases
+
+```ts
+"hi" satisfies { length: 3 };
+"hi" satisfies { length: 2 };
+(() => {}) satisfies Function;
```
-- Type { a: 1, b: 2, c: 3 } is not assignable to type { [string]: boolean }
+- Expected { length: 3 }, found "hi"
### Generic types
@@ -2688,17 +3452,18 @@ interface Wrapper {
internal: T
}
-const my_wrapped: Wrapper = { internal: "hi" }
+({ internal: "hi" } satisfies Wrapper);
+({ internal: "hi" } satisfies Wrapper);
```
-- Type { internal: "hi" } is not assignable to type Wrapper\
+- Expected Wrapper\, found { internal: \"hi\" }
#### Array property checking
```ts
const numbers1: Array = [1, 2, "3"],
- numbers2: Array = ["hi", "3"],
- numbers3: Array = 4;
+ numbers2: Array = ["hi", "3"],
+ numbers3: Array = 4;
```
- Type [1, 2, "3"] is not assignable to type Array\
@@ -2811,14 +3576,14 @@ myRecord.hello;
```
- Expected string, found number
-- No property 'hello' on { [\"hi\"]: number }.
+- No property 'hello' on { [\"hi\"]: number }
#### Assignment
```ts
const x: Record<"test", boolean> = { no: false },
- y: Record<"test", boolean> = { test: 6 },
- z: Record<"test", boolean> = { test: false };
+ y: Record<"test", boolean> = { test: 6 },
+ z: Record<"test", boolean> = { test: false };
```
- 'no' is not a property of { [\"test\"]: boolean }
@@ -2834,14 +3599,149 @@ obj1.hi satisfies boolean;
obj1.hello satisfies boolean;
obj1.bye;
+```
+
+- No property 'bye' on { ["hi" | "hello"]: boolean }
+
+#### Readonly and optionality carries through
+
+```ts
+type Mapped = {
+ [P in keyof T]: T[P]
+}
+
+interface Y { readonly a: string, b?: number }
+declare let x: Mapped;
+
+x.a = "hi";
+x.b satisfies number;
+```
+
+- Cannot write to property 'a'
+- Expected number, found number | undefined
+
+#### Specialisation
+
+```ts
+type Pick = {
+ [P in K]: T[P];
+};
+
+interface X { a: number, b: string, c: string }
+
+({ a: 5 } satisfies Pick);
+({ a: 5 } satisfies Pick);
+({ a: 5, b: "hi" } satisfies Pick);
+({ a: 5, b: 6 } satisfies Pick);
+
+declare let y: Pick;
+y.b satisfies string;
+y.a;
+```
+
+- Expected { ["a" | "b"]: X["a" | "b"] }, found { a: 5 }
+- Expected { ["a" | "b"]: X["a" | "b"] }, found { a: 5, b: 6 }
+- No property 'a' on { ["b" | "c"]: X["b" | "c"] }
+
+#### Optional
+
+```ts
+type Partial = {
+ [P in keyof T]?: T[P];
+};
+
+({ a: 3 } satisfies Partial<{ a: number, b: string }>);
+({ a: "hi" } satisfies Partial<{ a: number, b: string }>)
+```
+
+- Expected { [keyof { a: number, b: string }]?: { a: number, b: string }[keyof { a: number, b: string }] }, found { a: \"hi\" }
+
+#### Negated optionality
+
+```ts
+type Required = {
+ [P in keyof T]-?: T[P];
+};
+
+({ a: 3 } satisfies Required<{ a?: number }>);
+// Bad
+({ } satisfies Required<{ a?: number }>);
+```
+
+- Expected { [keyof { a?: number }]: { a?: number }[keyof { a?: number }] }, found {}
+
+#### Readonly
+
+```ts
+type Mutable = {
+ readonly [P in keyof T]: T[P];
+};
-declare let obj2: Record;
-obj2.fine satisfies boolean;
-obj2[2];
+interface Y { a: string }
+declare let x: Mutable;
+x.a = "hi";
```
-- No property 'bye' on { ["hi" | "hello"]: boolean }.
-- No property '2' on { [string]: boolean }.
+- Cannot write to property 'a'
+
+#### Negated readonly
+
+```ts
+type Mutable = {
+ -readonly [P in keyof T]: T[P];
+};
+
+interface Y { readonly a: string }
+declare let x: Mutable;
+x.a = "hi";
+x.a = 4;
+```
+
+- Type 4 does not meet property constraint "hi"
+
+#### `as` rewrite
+
+```ts
+type PrefixKeys = {
+ [P in ((keyof T) & string) as `property_${P}`]: T[P];
+};
+
+interface X { a: number };
+
+declare let x: PrefixKeys;
+x.property_a satisfies number;
+x.property_b
+```
+
+- No property 'property_b' on { [string]: X[keyof X & string] }
+
+### Readonly and `as const`
+
+> TODO constrained inference
+
+#### Readonly parameter
+
+```ts
+function x(p: readonly { a: string }) {
+ p.a = "hi";
+}
+```
+
+- Cannot write to property 'a'
+
+#### Readonly to readonly
+
+```ts
+function func1(p: { a: string, b: string }) {
+ func2(p)
+}
+function func2(p: readonly { a: string }) { }
+
+const obj = Object.freeze({ a: "hi" });
+func2(obj)
+```
+
+- Argument of type { a: string, b: string } is not assignable to parameter of type Readonly<{ a: string }>
### Forward inference
@@ -2853,13 +3753,13 @@ obj2[2];
```ts
interface MyObject {
- a(b: string): any;
+ a(b: string): any;
}
const obj: MyObject = {
- a(b) {
- b satisfies number;
- }
+ a(b) {
+ b satisfies number;
+ }
}
```
@@ -2869,11 +3769,11 @@ const obj: MyObject = {
```ts
function callFunction(fn: (p: T) => void) {
- // ...
+ // ...
}
callFunction(a => {
- a satisfies number;
+ a satisfies number;
})
```
@@ -2917,20 +3817,20 @@ obj1.a = "hello";
```ts
{
- const obj = { a: true, b: false };
- const x: { a: boolean } = obj, y: { b: boolean } = obj;
+ const obj = { a: true, b: false };
+ const x: { a: boolean } = obj, y: { b: boolean } = obj;
- obj.a = "yo";
- obj.b = "wassup";
+ obj.a = "yo";
+ obj.b = "wassup";
}
{
- // and in the same assignment through a cycle
- const obj = { a: 2, b: 3 }; obj.c = obj;
- const something: { a: number, c: { b: number } } = obj;
+ // and in the same assignment through a cycle
+ const obj = { a: 2, b: 3 }; obj.c = obj;
+ const something: { a: number, c: { b: number } } = obj;
- obj.a = "hi";
- obj.b = "hello";
+ obj.a = "hi";
+ obj.b = "hello";
}
```
@@ -2996,6 +3896,88 @@ const p_of_x = Object.getPrototypeOf(x);
- Expected string, found true
+### `Proxy`
+
+#### Proxy get
+
+```ts
+const proxy1 = new Proxy({ a: 2 }, { get(target: { a: number }, prop: string, receiver) {
+ if (prop === "a") {
+ return target["a"] + 1
+ }
+} } );
+
+proxy1.a satisfies string;
+```
+
+- Expected string, found 3
+
+#### Proxy set
+
+```ts
+let lastSet: string = "";
+const proxy1 = new Proxy({ a: 2 }, {
+ set(target: { a: number }, prop: string, value: number, receiver) {
+ lastSet = prop;
+ }
+});
+
+proxy1.a = 6;
+lastSet satisfies boolean;
+```
+
+- Expected boolean, found "a"
+
+#### Proxy handler fallthrough
+
+```ts
+const obj = { a: 2 };
+const proxy1 = new Proxy(obj, { });
+
+proxy1.a = 6;
+obj.a satisfies 6;
+proxy1.a satisfies string;
+```
+
+- Expected string, found 6
+
+#### Proxy subtyping
+
+```ts
+const proxy1 = new Proxy({}, { get(_target, prop, _recivier) { return prop } });
+
+proxy1 satisfies { a: "a", b: "b" };
+proxy1 satisfies { c: "d" };
+```
+
+- Expected { c: "d" }, found Proxy [ {}, { get: (_target: any, prop: any, _recivier: any) => any } ]
+
+#### Proxy across functions
+
+```ts
+function makeObservable(obj, cb: (kind: string, prop: string, value: any) => void) {
+ return new Proxy(obj, {
+ get(on, prop: string, _rec) {
+ cb("get", prop, on[prop])
+ },
+ set(on, prop: string, _value, _rec) {
+ cb("set", prop, on[prop])
+ },
+ })
+}
+
+let r = null;
+const value = makeObservable({ a: 1 }, (k, p, v) => {
+ r = { k, p, v };
+});
+
+r satisfies null;
+value.a = 2;
+r satisfies string;
+```
+
+- Expected string, found { k: "set", p: "a", v: 1 }
+
### Imports and exports
#### Import and export named
@@ -3086,7 +4068,7 @@ incrementCounter();
counter satisfies string;
// in mutable.ts
-export let counter = 2;
+export let counter: number = 2;
export function incrementCounter() {
counter++
}
@@ -3119,7 +4101,7 @@ console.log(a.prop);
export const a = 2;
```
-- Cannot find ./two.
+- Cannot find ./two
#### Import where export does not exist
@@ -3190,7 +4172,7 @@ export const x = 2;
const y = "122LH"
```
-- Could not find variable 'y' in scope. Did you mean x?
+- Could not find variable 'y' in scope
#### Import side effect
@@ -3227,7 +4209,7 @@ mean_gravity satisfies 2;
// in node_modules/earth/package.json
{
- "main": "constants.js"
+ "main": "constants.js"
}
// in node_modules/earth/constants.js
@@ -3236,9 +4218,9 @@ export const mean_gravity = 9.806;
- Expected 2, found 9.806
-### Extras
+### Stability
-> This contains new features. Most are WIP
+> What to do in the occurance of a type error
#### Use type annotation in the presence of error
@@ -3249,7 +4231,7 @@ const x: string = 5;
const y: string = h;
function getString(a: number): string {
- return a
+ return a
}
x satisfies string;
@@ -3260,50 +4242,36 @@ const z: number = getString(2);
- Cannot return number because the function is expected to return string
- Type 5 is not assignable to type string
-- Could not find variable 'h' in scope. Did you mean x, y or z?
+- Could not find variable 'h' in scope
- Type (error) string is not assignable to type number
-#### Unconditional throw
-
-```ts
-function safeDivide(num: number, denom: number) {
- if (denom === 0) {
- throw new Error("Cannot divide by zero");
- }
- return num / denom
-}
-
-safeDivide(8, 4) satisfies 2;
-
-safeDivide(10, 0);
-```
-
-- Conditional '[Error] { message: \"Cannot divide by zero\" }' was thrown in function
+#### Errors carries
-#### Unreachable statement
+> Note only one error raised. This prevents the compiler presenting loads of errors if an origin is invalid
```ts
-function throwGreeting() {
- throw "Hello";
- return "Unreachable!"
-}
+const obj = { prop: 2 };
+console.log(obj.a.b.c);
-function doSomething() {
- throwGreeting()
- const unreachable = 2;
+function x() {
+ return y
}
+
+x().nothing
```
-> One is for `return 5` the other is for `const x = 2;`
+- Could not find variable 'y' in scope
+- No property 'a' on { prop: 2 }
-- Unreachable statement
-- Unreachable statement
+### Extras
+
+> This contains new features. Most are WIP
#### JSX type
```tsx
function JSXH(tag_name: string, attributes: any, children: any) {
- return { tag_name, attributes, children }
+ return { tag_name, attributes, children }
}
const x = Hello World
satisfies string;
@@ -3315,7 +4283,7 @@ const x = Hello World
satisfies string;
```ts
function x(a /** string */) {
- a satisfies number
+ a satisfies number
}
const c /** number */ = "hello"
@@ -3328,7 +4296,7 @@ const c /** number */ = "hello"
```ts
function register(a: Literal) {
- // ...
+ // ...
}
register("something")
@@ -3338,20 +4306,68 @@ register(document.title)
- Argument of type string is not assignable to parameter of type Literal\
-#### Errors carries
+#### Number intrinsics
-> Note only one error raised. This prevents the compiler presenting loads of errors if an origin is invalid
+```ts
+5 satisfies MultipleOf<2>;
+4 satisfies MultipleOf<2>;
+
+6 satisfies GreaterThan<2>;
+-4 satisfies GreaterThan<2>;
+
+6 satisfies LessThan<2>;
+-4 satisfies LessThan<2>;
+```
+
+- Expected MultipleOf\<2\>, found 5
+- Expected GreaterThan\<2\>, found -4
+- Expected LessThan\<2\>, found 6
+
+#### `Not`
```ts
-const obj = { prop: 2 };
-console.log(obj.a.b.c);
+declare let a: number;
+4 satisfies Not<4>;
+6 satisfies Not<4>;
+a satisfies Not<8>;
+2 satisfies Not;
+"hi" satisfies Not;
-function x() {
- return y
-}
+declare let b: Not<5> & number;
+b satisfies number;
+b satisfies string;
+b satisfies 5;
+```
-x().nothing
+- Expected Not<4>, found 4
+- Expected Not<8>, found number
+- Expected Not\, found "hi"
+- Expected string, found Not<5> & number
+- Expected 5, found Not<5> & number
+
+#### `Exclusive`
+
+```ts
+interface X { a: number }
+const x = { a: 1, b: 2 };
+
+x satisfies Exclusive;
+({ a: 6 } satisfies Exclusive);
+```
+
+- Expected Exclusive\, found { a: 1, b: 2 }
+
+#### `CaseInsensitive`
+
+```ts
+"Hi" satisfies CaseInsensitive<"hi">;
+"Hello" satisfies CaseInsensitive<"hi">;
+
+// yeah
+type CIWord = "WORD" extends Uppercase ? T : never;
+"wOrd" satisfies CIWord;
+"wood" satisfies CIWord;
```
-- Could not find variable 'y' in scope. Did you mean x?
-- No property 'a' on { prop: 2 }.
+- Expected CaseInsensitive<"hi">, found "Hello"
+- Expected CIWord, found "wood"
diff --git a/checker/specification/test.rs b/checker/specification/test.rs
index c597d974..85166a18 100644
--- a/checker/specification/test.rs
+++ b/checker/specification/test.rs
@@ -34,6 +34,8 @@ mod specification {
// const SIMPLE_DTS: Option<&str> = Some(include_str!("../definitions/simple.d.ts"));
const SIMPLE_DTS: Option<&str> = None;
+const IN_CI: bool = option_env!("CI").is_some();
+
/// Called by each test
fn check_errors(
heading: &'static str,
@@ -63,31 +65,37 @@ fn check_errors(
// eprintln!("{:?}", code);
// let result = panic::catch_unwind(|| {
- eprintln!("{:?}", std::env::current_dir());
+
+ if IN_CI {
+ eprintln!("::group::Running {heading}");
+ }
+
let definition_file_name: PathBuf = if SIMPLE_DTS.is_some() {
"./checker/definitions/simple.d.ts".into()
} else {
checker::INTERNAL_DEFINITION_FILE_PATH.into()
};
- let type_definition_files = std::iter::once(definition_file_name.clone()).collect();
+ let type_definition_files = vec![definition_file_name.clone()];
+
+ let resolver = |path: &Path| -> Option> {
+ if path == definition_file_name.as_path() {
+ Some(SIMPLE_DTS.unwrap().to_owned().into_bytes())
+ } else if code.len() == 1 {
+ Some(code[0].1.to_owned().into())
+ } else {
+ code.iter()
+ .find_map(|(code_path, content)| {
+ (std::path::Path::new(code_path) == path)
+ .then_some(content.to_owned().to_owned())
+ })
+ .map(Into::into)
+ }
+ };
let result = checker::check_project::<_, EznoParser>(
vec![PathBuf::from("main.tsx")],
type_definition_files,
- |path: &Path| -> Option> {
- if path == definition_file_name.as_path() {
- Some(SIMPLE_DTS.unwrap().to_owned().into_bytes())
- } else if code.len() == 1 {
- Some(code[0].1.to_owned().into())
- } else {
- code.iter()
- .find_map(|(code_path, content)| {
- (std::path::Path::new(code_path) == path)
- .then_some(content.to_owned().to_owned())
- })
- .map(Into::into)
- }
- },
+ resolver,
type_check_options,
(),
None,
@@ -111,6 +119,10 @@ fn check_errors(
})
.collect();
+ if IN_CI {
+ eprintln!("::endgroup::");
+ }
+
if diagnostics != expected_diagnostics {
panic!(
"{}",
diff --git a/checker/specification/to_implement.md b/checker/specification/to_implement.md
index a4bbfa75..2cd6dc0f 100644
--- a/checker/specification/to_implement.md
+++ b/checker/specification/to_implement.md
@@ -3,19 +3,18 @@
### Types
-#### Resolving value by property on dependent
+#### Array slice matching pattern
```ts
-function getProperty(property: "a" | "b" | "c") {
- return { a: 1, b: 2, c: 3 }[property]
-}
+type Head = T extends [infer H, ...Array] ? H : never;
+
+type Tail = T extends [any, ...infer Tail] ? Tail : [];
-getProperty("d")
-getProperty("c") satisfies 2
+1 satisfies Head<[1, 2, 3, 4, 5]>;
+[2, 3, 4, 5] satisfies Tail<[1, 2, 3, 4, 5]>;
```
-- Expected "a" | "b" | "c" found "d"
-- Expected 2 found 3
+- Expected 1, found 2
#### Generic type argument restriction
@@ -56,21 +55,31 @@ print_type(mapper)
- TODO
-#### Function calling
+#### Calling or
-#### Calling on or type
+> *Calling* is distributive `(A | B)()` -> `A() | B()`
```ts
-type Func1 = () => 3;
-type Func2 = () => 2;
-function callFunc(func: (() => T) | (() => U)): 3 | 2 {
- return func()
+function a(p: string) { return 2 }
+function b(p: string) { return 4 }
+
+function c(c: boolean) {
+ const func = c ? a : b;
+ const result = func()
+ result satisfies string;
+ return result
}
+```
+
+- Expected string, found 2 | 4
-print_type(callFunc)
+#### Setter or
+
+```ts
+TODO
```
-- Expected "a" | "b" | "c" found "d"
+- Expected string, found 2 | 4
#### Getter and setter through function
@@ -93,6 +102,29 @@ x({ get b() { return 2 } })
- Expected string, found 5
+#### Spread object constraint
+
+```ts
+let { a, ...x }: { a: number, b: string } = { a: "hi", b: "hello" };
+x = 1;
+```
+
+- 1 is not assignable to { b: string }
+
+#### Known symbol inference & checking
+
+> #TODO extra
+
+```ts
+class X {
+ [Symbol.iterator]() {
+ return {}
+ }
+}
+```
+
+- ?
+
### Imports
#### Import package with definition file
@@ -177,22 +209,6 @@ function func(array: Array) {
- Expected number found string
-#### Order of properties
-
-> TODO this is because setting properties are simply appended. There are two straightforward fixes, but I am unsure which one is better...
-
-```ts
-const obj = { a: 1, b: 2 };
-obj.a = 2; obj.c = 6; obj.b = 4;
-let properties: string = "";
-for (const property in obj) {
- properties += property;
-}
-properties satisfies boolean;
-```
-
-- Expected boolean, found "abc"
-
### Inference
#### Parameter property
@@ -334,10 +350,6 @@ function x*() {
- TODO
-### `Proxy` and `Object`
-
-> TODO effects, different traps and `Object.defineProperty`
-
### Collections
#### `Array.fill`
@@ -367,6 +379,144 @@ declare let aNumber: number;
- Expected string, found boolean
+#### Array filter
+
+```ts
+[1, 2, 3].filter(x => x % 2 == 0) satisfies [2];
+```
+
+- ?
+
+#### Array slice
+
+```ts
+[1, 2, 3, 4, 5].slice(3) satisfies something;
+```
+
+- ?
+
+#### Array splice
+
+```ts
+const array = [1, 2, 3, 4, 5];
+array.splice(2);
+array satisfies something;
+```
+
+- ?
+
+#### Array shift and unshift
+
+```ts
+const array = [1, 2, 3];
+array.shift() satisfies not1;
+```
+
+- ?
+
+#### Array copying methods
+
+```ts
+// toReversed
+// with
+```
+
+- ?
+
+#### Array find & index of
+
+```ts
+// indexOf
+// lastIndexOf
+// find
+// findIndexOf
+```
+
+- ?
+
+#### Array constructor
+
+```ts
+new Array({ length: 5 }, (_, i) => i) satisfies string
+```
+
+- ?
+
+#### Array `concat` and spread push
+
+```ts
+// concat()
+// push(...x)
+```
+
+- ?
+
+#### Array values and entries
+
+> Iterators
+
+```ts
+const x =[1, 2, 3].values();
+```
+
+- ?
+
+#### Array flat
+
+```ts
+// flatten
+// flatMap
+```
+
+- ?
+
+#### Array reducers
+
+> May be hard bc reversed generics order
+
+```ts
+// reduce
+// reduceRight
+```
+
+- ?
+
+#### Map `set` and `get`
+
+```ts
+const x = new Map();
+x.set(4, 2);
+x.set(4, 3);
+x.get(4) satisfies 2;
+x.get(2) satisfies string;
+```
+
+- Expected 2, found 3
+- Expected string, found undefined
+
+#### Map `items`
+
+```ts
+const x = new Map();
+x.items()
+```
+
+- ?
+
+#### Map generics
+
+```ts
+const x: Map = new Map();
+x.set(4, false);
+
+const y = new Map();
+y.set(6, 2);
+y.set(4, "hi");
+y satisfies string;
+```
+
+- Expected string, found Map<6 | 4, 2 | "hi">
+
### Expressions
#### Bad arithmetic operator
@@ -417,33 +567,6 @@ declare const global: { a?: string };
- Expected string, found boolean
- Expected 2, found string | undefined
-#### Delete from required propertied
-
-```ts
-declare let global: { a?: string, b: string };
-
-// Fine
-delete global.a;
-// Bad
-delete global.b;
-```
-
-- Cannot delete property "b" off { a?: string, b: string }
-
-#### Optional property access
-
-```ts
-interface X {
- possibly?: string
-}
-
-declare let x: X;
-
-x?.possibly satisfies number;
-```
-
-- Expected string, found string | undefined
-
### Runtime
#### Free variable + anytime calls
@@ -517,6 +640,21 @@ class Rectangle implements Draw {
- Class "MyNumber", does not implement draw
- Expected string, found CanvasRenderingContext2D
+#### Via effect
+
+```ts
+function newClass(property, value) {
+ return class {
+ [property] = value
+ }
+}
+
+new (newClass("hello", 2)).hello satisfies 2;
+new (newClass("hi", 6)).hi satisfies string;
+```
+
+- Expected string, found 6
+
### Recursion
#### Application
@@ -571,18 +709,6 @@ a satisfies 3; b satisfies string;
### Functions
-#### No generics
-
-```ts
-function id(a) { return a }
-
-id<5>(4)
-```
-
-- Cannot pass generic arguments to function without generic arguments
-
-> Or at least explicit generic arguments
-
#### Method overloading
```ts
@@ -671,63 +797,173 @@ if (b === "hi") {
- Expected "hello", found "hi"
-### Mapped types
+#### Optional property access
-#### Specialisation
+```ts
+interface X {
+ a: string
+ b: string
+}
+
+declare let x: X | null;
+
+x.a;
+x?.b satisfies number;
+```
+
+- Cannot get 'a' on null
+- Expected number, found string
+
+### Generics
+
+#### Out of order generics
```ts
-type Pick = {
- [P in K]: T[P];
-};
+function func(cb: (t: T) => number, value: T) { }
-interface X { a: number, b: string, c: string }
+func(cb => { cb satisfies boolean }, "hi")
+```
-const x: Pick = { a: 5 };
+- Expected boolean, found "hi"
-({ b: "string" }) satisfies Pick;
+### Broken
+
+> Was working, now broken (or removed)
+
+#### Readonly property
+
+> Should be working but parser current wraps `a` as `Readonly` :(
+
+```ts
+function x(p: { readonly a: string, b: string }) {
+ p.a = "hi";
+ p.b = "hi";
+}
```
-- TODO
+- Cannot write to property 'a'
-#### Optional
+#### Destructuring using iterator
```ts
-type Partial = {
- [P in keyof T]?: T[P];
-};
+const [a, b, c] = {
+ [Symbol.iterator]() {
+ return {
+ count: 0,
+ next(this: { count: number }) {
+ return { value: this.count++, done: false }
+ }
+ }
+ }
+}
-const x: Partial<{ a: number, b: string }> = { a: 3 },
- y: Partial<{ a: number, b: string }> = { a: "hi" }
+a satisfies 0; b satisfies string;
```
-- Cannot assign { a: "hi" }
+- Expected string, found 1
-#### Negated
+#### Always known math
```ts
-type Required = {
- [P in keyof T]-?: T[P];
-};
+function func(a: number) { return a ** 0 }
+
+print_type(func)
-const x: Required<{ a?: number }> = { a: 3 },
- y: Required<{ a?: number }> = { };
+declare let x: NotNotANumber;
+
+print_type(x ** 1 === x)
```
-- Cannot assign { } to required
+- Expected string, found 1
+- True
-### Readonly and `as const`
+#### Less than checks
-> TODO constrained inference
+```ts
+function x(a: GreaterThan<4>) {
+ (a < 3) satisfies false;
+ (a < 10) satisfies string;
+}
+```
-#### Readonly parameter
+- Expected string, found boolean
+
+#### Tagged template literal
+
+> Waiting for parser definition updated to make this easier
+
+```ts
+function myTag(static_parts: Array, other: string) {
+ return { static_parts, other }
+}
+
+const name = "Ben";
+myTag`${name}Hello ` satisfies string
+```
+
+- Expected string, found { static_parts: ["", "Hello "], other: "Ben" }
+
+### Control flow
+
+#### Conditional break
+
+```ts
+function getNumber(a: number) {
+ for (let i = 0; i < 10; i++) {
+ if (i === a) {
+ return "found"
+ }
+ }
+ return "not-found"
+}
+
+getNumber(4) satisfies "found";
+getNumber(100) satisfies boolean;
+```
+
+- Expected boolean, found "not-found"
+
+#### *Inconclusive* conditional update
```ts
-function x(p: readonly { a: string }) {
- p.a = 5;
+declare var value: string;
+let a: string | number = 0;
+
+function conditional(v: string) {
+ if (v === "value") {
+ a = "hi"
+ }
}
+conditional(value);
+a satisfies string;
```
-- Cannot assign to immutable property
+- Expected string, found "hi" | 0
+
+#### Break with label
+
+> Note the numbers here, if they are larger they break over the `max_inline` limit and get different results below
+
+```ts
+let a: number = 0;
+let result;
+
+top: while (a++ < 8) {
+ let b: number = 0;
+ while (b++ < 8) {
+ if (a === 3 && b === 2) {
+ result = a * b;
+ break top
+ }
+ }
+}
+
+a satisfies string;
+result satisfies boolean;
+```
+
+- Expected string, found 3
+- Expected boolean, found 6
### Closures
@@ -802,97 +1038,46 @@ x.a = "hi"
- Cannot assign. Restricted to number
-### Exceptions and `try-catch-finally`
-
-#### Conditional throw
+### Others
-> This emits a warning if a throw was created in a conditional branch
+#### Pure getter assignment
```ts
-// no complex numbers :(
-function checkedLn(x: number) {
- if (x > 0) {
- return Math.log(x)
- } else {
- throw new Exception("Cannot log long string")
- }
+function func(p: Pure<{ prop: number }>) {
+ p.prop = 2;
+ p.prop satisfies string;
}
-
-// Fine
-try { checkedLn(Math.E ** 3) satisfies 3 } catch {}
-// Will throw
-try { checkedLn(-5) } catch {}
```
-- Conditional 'Exception' was thrown in function
-
-### Broken
-
-> Was working, now not
+- Expected string, found 2
-#### `find` and `includes`
+#### Deep readonly
-> TODO other arguments (index and `this`). and poly
+> TODO implement use mapped type `T & { [P in keyof T]: Readonly }`
```ts
-[1, 2, 3].find(x => x % 2 === 0) satisfies 4;
-
-// [1, 2, 3].includes(6) satisfies string;
+declare const obj: DeepReadonly<{ a: { b: { c: 2 } } };
+obj.a.b.c = 2;
```
-- Expected 4, found 2
-
+- Cannot assign to readonly
-#### Conditional return type inference
+#### Conditionality destructuring from poly
```ts
-function func(a: boolean) {
- if (a) {
- return 2
- }
-}
-
-func satisfies (a: boolean) => 5;
+declare let x: { a?: 1 }; // also { a: 1 } | { b: 2 }
+let { a = 2 } = x;
+a satisfies 3;
```
-- Expected (a: boolean) => 5, found (a: boolean) => 2 | undefined
+- Expected 3, found 1 | 2
-#### *Inconclusive* conditional update
-
-```ts
-declare var value: string;
-let a: string | number = 0;
-
-function conditional(v: string) {
- if (v === "value") {
- a = "hi"
- }
-}
-conditional(value);
-a satisfies string;
-```
-
-- Expected string, found "hi" | 0
+### RegExp
-#### Break with label
+#### Regexp patterns
```ts
-let a: number = 0;
-let result;
-
-top: while (a++ < 10) {
- let b: number = 0;
- while (b++ < 10) {
- if (a === 3 && b === 2) {
- result = a * b;
- break top
- }
- }
-}
-
-a satisfies string;
-result satisfies boolean;
+new RegExp("x").group.string
```
-- Expected string, found 3
-- Expected boolean, found 6
+- ?
diff --git a/checker/src/context/control_flow.rs b/checker/src/context/control_flow.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/checker/src/context/control_flow.rs
@@ -0,0 +1 @@
+
diff --git a/checker/src/context/environment.rs b/checker/src/context/environment.rs
index b2a5743e..c7d019be 100644
--- a/checker/src/context/environment.rs
+++ b/checker/src/context/environment.rs
@@ -2,19 +2,19 @@ use source_map::{SourceId, Span, SpanWithSource};
use std::collections::{HashMap, HashSet};
use crate::{
- context::get_on_ctx,
+ context::{get_on_ctx, information::ReturnState},
diagnostics::{
- NotInLoopOrCouldNotFindLabel, PropertyRepresentation, TypeCheckError,
+ NotInLoopOrCouldNotFindLabel, PropertyKeyRepresentation, TypeCheckError,
TypeStringRepresentation, TDZ,
},
events::{Event, FinalEvent, RootReference},
features::{
assignments::{
Assignable, AssignableArrayDestructuringField, AssignableObjectDestructuringField,
- AssignmentKind, Reference,
+ AssignmentKind, AssignmentReturnStatus, IncrementOrDecrement, Reference,
},
modules::Exported,
- objects::SpecialObjects,
+ objects::SpecialObject,
operations::{
evaluate_logical_operation_with_expression,
evaluate_pure_binary_operation_handle_errors, MathematicalAndBitwise,
@@ -23,24 +23,31 @@ use crate::{
},
subtyping::{type_is_subtype, type_is_subtype_object, State, SubTypeResult, SubTypingOptions},
types::{
- printing,
properties::{
- get_property_key_names_on_a_single_type, PropertyKey, PropertyKind, PropertyValue,
+ get_property_key_names_on_a_single_type, AccessMode, PropertyKey, PropertyKind,
Publicity,
},
PolyNature, Type, TypeStore,
},
- CheckingData, Instance, RootContext, TypeCheckOptions, TypeId,
+ CheckingData, Instance, RootContext, TypeId,
};
use super::{
- get_value_of_variable, information::InformationChain, invocation::CheckThings, AssignmentError,
- ClosedOverReferencesInScope, Context, ContextType, Environment, GeneralContext,
- SetPropertyError,
+ get_value_of_variable, invocation::CheckThings, AssignmentError, ClosedOverReferencesInScope,
+ Context, ContextType, Environment, GeneralContext, InformationChain,
};
+/// For WIP contextual access of certain APIs
pub type ContextLocation = Option;
+/// Error type for something already being defined
+pub struct AlreadyExists;
+
+pub enum DeclareInterfaceResult {
+ Merging { ty: TypeId, in_same_context: bool },
+ New(TypeId),
+}
+
#[derive(Debug)]
pub struct Syntax<'a> {
pub scope: Scope,
@@ -239,19 +246,13 @@ impl<'a> Environment<'a> {
/// Handles all assignments, including updates and destructuring
///
/// Will evaluate the expression with the right timing and conditions, including never if short circuit
- ///
- /// TODO finish operator. Unify increment and decrement. The RHS span should be fine with [`Span::NULL ...?`] Maybe RHS type could be None to accommodate
- pub fn assign_to_assignable_handle_errors<
- 'b,
- T: crate::ReadFromFS,
- A: crate::ASTImplementation,
- >(
+ pub fn assign_handle_errors<'b, T: crate::ReadFromFS, A: crate::ASTImplementation>(
&mut self,
lhs: Assignable,
operator: AssignmentKind,
// Can be `None` for increment and decrement
expression: Option<&'b A::Expression<'b>>,
- assignment_span: Span,
+ assignment_position: Span,
checking_data: &mut CheckingData,
) -> TypeId {
match lhs {
@@ -265,17 +266,24 @@ impl<'a> Environment<'a> {
checking_data,
);
- self.assign_to_reference_assign_handle_errors(
+ let assignment_position =
+ assignment_position.with_source(self.get_source());
+ self.set_reference_handle_errors(
reference,
rhs,
+ assignment_position,
checking_data,
- assignment_span,
- )
+ );
+ rhs
}
AssignmentKind::PureUpdate(operator) => {
// Order matters here
let reference_position = reference.get_position();
- let existing = self.get_reference(reference.clone(), checking_data, true);
+ let existing = self.get_reference(
+ reference.clone(),
+ checking_data,
+ AccessMode::Regular,
+ );
let expression = expression.unwrap();
let expression_pos =
@@ -294,39 +302,33 @@ impl<'a> Environment<'a> {
checking_data,
self,
);
- let result = self.set_reference(reference, new, checking_data);
- match result {
- Ok(ty) => ty,
- Err(error) => {
- let error = set_property_error_to_type_check_error(
- self,
- error,
- assignment_span.with_source(self.get_source()),
- &checking_data.types,
- new,
- );
- checking_data.diagnostics_container.add_error(error);
- TypeId::ERROR_TYPE
- }
- }
+ let assignment_position =
+ assignment_position.with_source(self.get_source());
+ self.set_reference_handle_errors(
+ reference,
+ new,
+ assignment_position,
+ checking_data,
+ );
+ new
}
AssignmentKind::IncrementOrDecrement(direction, return_kind) => {
// let value =
- // self.get_variable_or_error(&name, &assignment_span, checking_data);
- let span = reference.get_position();
- let existing = self.get_reference(reference.clone(), checking_data, true);
+ // self.get_variable_or_error(&name, &assignment_position, checking_data);
+ let position = reference.get_position();
+ let existing = self.get_reference(
+ reference.clone(),
+ checking_data,
+ AccessMode::Regular,
+ );
// TODO existing needs to be cast to number!!
let new = evaluate_pure_binary_operation_handle_errors(
- (existing, span),
+ (existing, position),
match direction {
- crate::features::assignments::IncrementOrDecrement::Increment => {
- MathematicalAndBitwise::Add
- }
- crate::features::assignments::IncrementOrDecrement::Decrement => {
- MathematicalAndBitwise::Subtract
- }
+ IncrementOrDecrement::Increment => MathematicalAndBitwise::Add,
+ IncrementOrDecrement::Decrement => MathematicalAndBitwise::Subtract,
}
.into(),
(TypeId::ONE, source_map::Nullable::NULL),
@@ -334,30 +336,26 @@ impl<'a> Environment<'a> {
self,
);
- let result = self.set_reference(reference, new, checking_data);
+ let assignment_position =
+ assignment_position.with_source(self.get_source());
+ self.set_reference_handle_errors(
+ reference,
+ new,
+ assignment_position,
+ checking_data,
+ );
- match result {
- Ok(new) => match return_kind {
- crate::features::assignments::AssignmentReturnStatus::Previous => {
- existing
- }
- crate::features::assignments::AssignmentReturnStatus::New => new,
- },
- Err(error) => {
- let error = set_property_error_to_type_check_error(
- self,
- error,
- assignment_span.with_source(self.get_source()),
- &checking_data.types,
- new,
- );
- checking_data.diagnostics_container.add_error(error);
- TypeId::ERROR_TYPE
- }
+ match return_kind {
+ AssignmentReturnStatus::Previous => existing,
+ AssignmentReturnStatus::New => new,
}
}
AssignmentKind::ConditionalUpdate(operator) => {
- let existing = self.get_reference(reference.clone(), checking_data, true);
+ let existing = self.get_reference(
+ reference.clone(),
+ checking_data,
+ AccessMode::Regular,
+ );
let expression = expression.unwrap();
let new = evaluate_logical_operation_with_expression(
(existing, reference.get_position().without_source()),
@@ -365,25 +363,19 @@ impl<'a> Environment<'a> {
expression,
checking_data,
self,
+ TypeId::ANY_TYPE,
)
.unwrap();
- let result = self.set_reference(reference, new, checking_data);
-
- match result {
- Ok(new) => new,
- Err(error) => {
- let error = set_property_error_to_type_check_error(
- self,
- error,
- assignment_span.with_source(self.get_source()),
- &checking_data.types,
- new,
- );
- checking_data.diagnostics_container.add_error(error);
- TypeId::ERROR_TYPE
- }
- }
+ let assignment_position =
+ assignment_position.with_source(self.get_source());
+ self.set_reference_handle_errors(
+ reference,
+ new,
+ assignment_position,
+ checking_data,
+ );
+ new
}
}
}
@@ -400,9 +392,11 @@ impl<'a> Environment<'a> {
self.assign_to_object_destructure_handle_errors(
members,
rhs,
- assignment_span,
+ assignment_position.with_source(self.get_source()),
checking_data,
- )
+ );
+
+ rhs
}
Assignable::ArrayDestructuring(members, _spread) => {
debug_assert!(matches!(operator, AssignmentKind::Assign));
@@ -417,67 +411,43 @@ impl<'a> Environment<'a> {
self.assign_to_array_destructure_handle_errors(
members,
rhs,
- assignment_span,
+ assignment_position.with_source(self.get_source()),
checking_data,
- )
- }
- }
- }
-
- fn assign_to_reference_assign_handle_errors<
- T: crate::ReadFromFS,
- A: crate::ASTImplementation,
- >(
- &mut self,
- reference: Reference,
- rhs: TypeId,
- checking_data: &mut CheckingData,
- assignment_span: source_map::BaseSpan<()>,
- ) -> TypeId {
- let result = self.set_reference(reference, rhs, checking_data);
-
- match result {
- Ok(ty) => ty,
- Err(error) => {
- let error = set_property_error_to_type_check_error(
- self,
- error,
- assignment_span.with_source(self.get_source()),
- &checking_data.types,
- rhs,
);
- checking_data.diagnostics_container.add_error(error);
- TypeId::ERROR_TYPE
+
+ rhs
}
}
}
- fn assign_to_assign_only_handle_errors(
+ fn assign_to_assignable_handle_errors(
&mut self,
lhs: Assignable,
rhs: TypeId,
- assignment_span: Span,
+ assignment_position: SpanWithSource,
checking_data: &mut CheckingData,
- ) -> TypeId {
+ ) {
match lhs {
- Assignable::Reference(reference) => self.assign_to_reference_assign_handle_errors(
- reference,
- rhs,
- checking_data,
- assignment_span,
- ),
+ Assignable::Reference(reference) => {
+ self.set_reference_handle_errors(
+ reference,
+ rhs,
+ assignment_position,
+ checking_data,
+ );
+ }
Assignable::ObjectDestructuring(assignments, _spread) => self
.assign_to_object_destructure_handle_errors(
assignments,
rhs,
- assignment_span,
+ assignment_position,
checking_data,
),
Assignable::ArrayDestructuring(assignments, _spread) => self
.assign_to_array_destructure_handle_errors(
assignments,
rhs,
- assignment_span,
+ assignment_position,
checking_data,
),
}
@@ -490,29 +460,38 @@ impl<'a> Environment<'a> {
&mut self,
assignments: Vec>,
rhs: TypeId,
- assignment_span: Span,
+ assignment_position: SpanWithSource,
checking_data: &mut CheckingData,
- ) -> TypeId {
+ ) {
for assignment in assignments {
match assignment {
AssignableObjectDestructuringField::Mapped {
- on,
+ key,
name,
default_value,
position,
} => {
- let value = self.get_property(
+ // TODO conditionaly
+ let mut diagnostics = Default::default();
+ let result = crate::types::properties::get_property(
rhs,
Publicity::Public,
- &on,
+ &key,
+ self,
+ (
+ &mut CheckThings { debug_types: checking_data.options.debug_types },
+ &mut diagnostics,
+ ),
&mut checking_data.types,
- None,
position,
- &checking_data.options,
- false,
+ AccessMode::DoNotBindThis,
+ );
+ diagnostics.append_to(
+ crate::types::calling::CallingContext::Getter,
+ &mut checking_data.diagnostics_container,
);
- let rhs_value = if let Some((_, value)) = value {
+ let rhs_value = if let Some((_, value)) = result {
value
} else if let Some(default_value) = default_value {
A::synthesise_expression(
@@ -522,51 +501,55 @@ impl<'a> Environment<'a> {
checking_data,
)
} else {
+ let keys;
+ let possibles = if let PropertyKey::String(s) = &key {
+ keys = get_property_key_names_on_a_single_type(
+ rhs,
+ &checking_data.types,
+ self,
+ );
+ let mut possibles =
+ crate::get_closest(keys.iter().map(AsRef::as_ref), s)
+ .unwrap_or(vec![]);
+ possibles.sort_unstable();
+ possibles
+ } else {
+ Vec::new()
+ };
checking_data.diagnostics_container.add_error(
TypeCheckError::PropertyDoesNotExist {
- property: match on {
- PropertyKey::String(s) => {
- PropertyRepresentation::StringKey(s.to_string())
- }
- PropertyKey::Type(t) => PropertyRepresentation::Type(
- printing::print_type(t, &checking_data.types, self, false),
- ),
- },
+ property: PropertyKeyRepresentation::new(
+ &key,
+ self,
+ &checking_data.types,
+ ),
on: TypeStringRepresentation::from_type_id(
rhs,
self,
&checking_data.types,
false,
),
- site: position,
- possibles: get_property_key_names_on_a_single_type(
- rhs,
- &mut checking_data.types,
- self,
- )
- .iter()
- .map(AsRef::as_ref)
- .collect::>(),
+ position,
+ possibles,
},
);
TypeId::ERROR_TYPE
};
- self.assign_to_assign_only_handle_errors(
+ self.assign_to_assignable_handle_errors(
name,
rhs_value,
- assignment_span,
+ assignment_position,
checking_data,
);
}
}
}
-
- rhs
}
#[allow(clippy::needless_pass_by_value)]
+ #[allow(clippy::unused_self)]
fn assign_to_array_destructure_handle_errors<
T: crate::ReadFromFS,
A: crate::ASTImplementation,
@@ -574,35 +557,31 @@ impl<'a> Environment<'a> {
&mut self,
_assignments: Vec>,
_rhs: TypeId,
- assignment_span: Span,
+ assignment_position: SpanWithSource,
checking_data: &mut CheckingData,
- ) -> TypeId {
- checking_data.raise_unimplemented_error(
- "destructuring array (needs iterator)",
- assignment_span.with_source(self.get_source()),
- );
-
- TypeId::ERROR_TYPE
+ ) {
+ checking_data
+ .raise_unimplemented_error("destructuring array (needs iterator)", assignment_position);
}
fn get_reference(
&mut self,
reference: Reference,
checking_data: &mut CheckingData,
- bind_this: bool,
+ mode: AccessMode,
) -> TypeId {
match reference {
Reference::Variable(name, position) => {
self.get_variable_handle_error(&name, position, checking_data).unwrap().1
}
- Reference::Property { on, with, publicity, span } => {
+ Reference::Property { on, with, publicity, position } => {
let get_property_handle_errors = self.get_property_handle_errors(
on,
publicity,
&with,
checking_data,
- span,
- bind_this,
+ position,
+ mode,
);
match get_property_handle_errors {
Ok(i) => i.get_value(),
@@ -612,30 +591,20 @@ impl<'a> Environment<'a> {
}
}
- fn set_reference(
+ fn set_reference_handle_errors(
&mut self,
reference: Reference,
rhs: TypeId,
+ _position: SpanWithSource,
checking_data: &mut CheckingData,
- ) -> Result {
+ ) {
match reference {
- Reference::Variable(name, position) => Ok(self.assign_to_variable_handle_errors(
- name.as_str(),
- position,
- rhs,
- checking_data,
- )),
- Reference::Property { on, with, publicity, span } => Ok(self
- .set_property(
- on,
- publicity,
- &with,
- rhs,
- &mut checking_data.types,
- span,
- &checking_data.options,
- )?
- .unwrap_or(rhs)),
+ Reference::Variable(name, position) => {
+ self.assign_to_variable_handle_errors(name.as_str(), position, rhs, checking_data);
+ }
+ Reference::Property { on, with, publicity, position } => {
+ self.set_property_handle_errors(on, publicity, &with, rhs, position, checking_data);
+ }
}
}
@@ -645,7 +614,7 @@ impl<'a> Environment<'a> {
assignment_position: SpanWithSource,
new_type: TypeId,
checking_data: &mut CheckingData,
- ) -> TypeId {
+ ) {
let result = self.assign_to_variable(
variable_name,
assignment_position,
@@ -653,12 +622,11 @@ impl<'a> Environment<'a> {
&mut checking_data.types,
);
match result {
- Ok(ok) => ok,
+ Ok(()) => {}
Err(error) => {
checking_data
.diagnostics_container
.add_error(TypeCheckError::AssignmentError(error));
- TypeId::ERROR_TYPE
}
}
}
@@ -670,68 +638,70 @@ impl<'a> Environment<'a> {
assignment_position: SpanWithSource,
new_type: TypeId,
types: &mut TypeStore,
- ) -> Result {
+ ) -> Result<(), AssignmentError> {
// Get without the effects
let variable_in_map = self.get_variable_unbound(variable_name);
if let Some((_, boundary, variable)) = variable_in_map {
match variable {
- VariableOrImport::Variable { mutability, declared_at, context: _ } => {
- match mutability {
- VariableMutability::Constant => {
- Err(AssignmentError::Constant(*declared_at))
+ VariableOrImport::Variable {
+ mutability,
+ declared_at,
+ context: _,
+ allow_reregistration: _,
+ } => match mutability {
+ VariableMutability::Constant => Err(AssignmentError::Constant(*declared_at)),
+ VariableMutability::Mutable { reassignment_constraint } => {
+ let variable = variable.clone();
+ let variable_position = *declared_at;
+ let variable_id = variable.get_id();
+
+ if boundary.is_none()
+ && !self
+ .get_chain_of_info()
+ .any(|info| info.variable_current_value.contains_key(&variable_id))
+ {
+ return Err(AssignmentError::TDZ(TDZ {
+ position: assignment_position,
+ variable_name: variable_name.to_owned(),
+ }));
}
- VariableMutability::Mutable { reassignment_constraint } => {
- let variable = variable.clone();
- let variable_site = *declared_at;
- let variable_id = variable.get_id();
-
- if boundary.is_none()
- && !self.get_chain_of_info().any(|info| {
- info.variable_current_value.contains_key(&variable_id)
- }) {
- return Err(AssignmentError::TDZ(TDZ {
- position: assignment_position,
- variable_name: variable_name.to_owned(),
- }));
- }
-
- if let Some(reassignment_constraint) = *reassignment_constraint {
- let result = type_is_subtype_object(
- reassignment_constraint,
- new_type,
- self,
- types,
- );
- if let SubTypeResult::IsNotSubType(_mismatches) = result {
- return Err(AssignmentError::DoesNotMeetConstraint {
- variable_type: TypeStringRepresentation::from_type_id(
- reassignment_constraint,
- self,
- types,
- false,
- ),
- value_type: TypeStringRepresentation::from_type_id(
- new_type, self, types, false,
- ),
- variable_site,
- value_site: assignment_position,
- });
- }
+ if let Some(reassignment_constraint) = *reassignment_constraint {
+ let result = type_is_subtype_object(
+ reassignment_constraint,
+ new_type,
+ self,
+ types,
+ );
+
+ if let SubTypeResult::IsNotSubType(_mismatches) = result {
+ return Err(AssignmentError::DoesNotMeetConstraint {
+ variable_type: TypeStringRepresentation::from_type_id(
+ reassignment_constraint,
+ self,
+ types,
+ false,
+ ),
+ value_type: TypeStringRepresentation::from_type_id(
+ new_type, self, types, false,
+ ),
+ variable_position,
+ value_position: assignment_position,
+ });
}
+ }
- self.info.events.push(Event::SetsVariable(
- variable_id,
- new_type,
- assignment_position,
- ));
- self.info.variable_current_value.insert(variable_id, new_type);
+ self.info.events.push(Event::SetsVariable(
+ variable_id,
+ new_type,
+ assignment_position,
+ ));
+ self.info.variable_current_value.insert(variable_id, new_type);
- Ok(new_type)
- }
+ Ok(())
}
- }
+ },
VariableOrImport::MutableImport { .. }
| VariableOrImport::ConstantImport { .. } => {
Err(AssignmentError::Constant(assignment_position))
@@ -770,51 +740,6 @@ impl<'a> Environment<'a> {
self.context_type.requests.extend(requests);
}
- /// TODO decidable & private?
- #[must_use]
- pub fn property_in(&self, on: TypeId, property: &PropertyKey) -> bool {
- self.get_chain_of_info().any(|info| match info.current_properties.get(&on) {
- Some(v) => {
- v.iter().any(
- |(_, p, v)| if let PropertyValue::Deleted = v { false } else { p == property },
- )
- }
- None => false,
- })
- }
-
- /// TODO decidable & private?
- pub fn delete_property(
- &mut self,
- on: TypeId,
- property: &PropertyKey,
- position: SpanWithSource,
- ) -> bool {
- let existing = self.property_in(on, property);
-
- let under = property.into_owned();
-
- // on_default() okay because might be in a nested context.
- // entry empty does not mean no properties, just no properties set on this level
- self.info.current_properties.entry(on).or_default().push((
- Publicity::Public,
- under.clone(),
- PropertyValue::Deleted,
- ));
-
- // TODO Event::Delete. Dependent result based on in
- self.info.events.push(Event::Setter {
- on,
- under,
- new: PropertyValue::Deleted,
- initialization: false,
- publicity: Publicity::Public,
- position,
- });
-
- existing
- }
-
pub(crate) fn get_parent(&self) -> GeneralContext {
match self.context_type.parent {
GeneralContext::Syntax(syn) => GeneralContext::Syntax(syn),
@@ -822,51 +747,51 @@ impl<'a> Environment<'a> {
}
}
- #[allow(clippy::too_many_arguments)]
- pub fn get_property(
- &mut self,
- on: TypeId,
- publicity: Publicity,
- property: &PropertyKey,
- types: &mut TypeStore,
- with: Option,
- position: SpanWithSource,
- options: &TypeCheckOptions,
- bind_this: bool,
- ) -> Option<(PropertyKind, TypeId)> {
- crate::types::properties::get_property(
- on,
- publicity,
- property,
- with,
- self,
- &mut CheckThings { debug_types: options.debug_types },
- types,
- position,
- bind_this,
- )
- }
-
pub fn get_property_handle_errors(
&mut self,
on: TypeId,
publicity: Publicity,
- key: &PropertyKey,
+ under: &PropertyKey,
checking_data: &mut CheckingData,
- site: SpanWithSource,
- bind_this: bool,
+ position: SpanWithSource,
+ mode: AccessMode,
) -> Result {
- let get_property = self.get_property(
+ // let get_property = if let AccessMode::Optional = mode {
+ // let is_lhs_null = evaluate_equality_inequality_operation(
+ // lhs.0,
+ // &EqualityAndInequality::StrictEqual,
+ // TypeId::NULL_TYPE,
+ // &mut checking_data.types,
+ // checking_data.options.strict_casts,
+ // )?;
+ // Ok(new_conditional_context(
+ // environment,
+ // (is_lhs_null, lhs.1),
+ // |env: &mut Environment, data: &mut CheckingData| {
+ // A::synthesise_expression(rhs, TypeId::ANY_TYPE, env, data)
+ // },
+ // Some(|_env: &mut Environment, _data: &mut CheckingData| lhs.0),
+ // checking_data,
+ // ))
+ // } else {
+ let mut diagnostics = Default::default();
+ let get_property = crate::types::properties::get_property(
on,
publicity,
- key,
+ under,
+ self,
+ (&mut CheckThings { debug_types: checking_data.options.debug_types }, &mut diagnostics),
&mut checking_data.types,
- None,
- site,
- &checking_data.options,
- bind_this,
+ position,
+ mode,
+ );
+ diagnostics.append_to(
+ crate::types::calling::CallingContext::Getter,
+ &mut checking_data.diagnostics_container,
);
+ // };
+
if let Some((kind, result)) = get_property {
Ok(match kind {
PropertyKind::Getter => Instance::GValue(result),
@@ -876,32 +801,26 @@ impl<'a> Environment<'a> {
}
})
} else {
+ let keys;
+ let possibles = if let PropertyKey::String(s) = under {
+ keys = get_property_key_names_on_a_single_type(on, &checking_data.types, self);
+ let mut possibles =
+ crate::get_closest(keys.iter().map(AsRef::as_ref), s).unwrap_or(vec![]);
+ possibles.sort_unstable();
+ possibles
+ } else {
+ Vec::new()
+ };
checking_data.diagnostics_container.add_error(TypeCheckError::PropertyDoesNotExist {
- // TODO printing temp
- property: match key {
- PropertyKey::String(s) => PropertyRepresentation::StringKey(s.to_string()),
- PropertyKey::Type(t) => PropertyRepresentation::Type(printing::print_type(
- *t,
- &checking_data.types,
- self,
- false,
- )),
- },
+ property: PropertyKeyRepresentation::new(under, self, &checking_data.types),
on: crate::diagnostics::TypeStringRepresentation::from_type_id(
on,
self,
&checking_data.types,
false,
),
- site,
- possibles: get_property_key_names_on_a_single_type(
- on,
- &mut checking_data.types,
- self,
- )
- .iter()
- .map(AsRef::as_ref)
- .collect::>(),
+ position,
+ possibles,
});
Err(())
}
@@ -919,12 +838,14 @@ impl<'a> Environment<'a> {
if let Some((in_root, crossed_boundary, og_var)) = variable_information {
(in_root, crossed_boundary, og_var.clone())
} else {
+ let possibles = {
+ let mut possibles =
+ crate::get_closest(self.get_all_variable_names(), name).unwrap_or(vec![]);
+ possibles.sort_unstable();
+ possibles
+ };
checking_data.diagnostics_container.add_error(
- TypeCheckError::CouldNotFindVariable {
- variable: name,
- possibles: self.get_all_variable_names(),
- position,
- },
+ TypeCheckError::CouldNotFindVariable { variable: name, possibles, position },
);
return Err(TypeId::ERROR_TYPE);
}
@@ -985,7 +906,7 @@ impl<'a> Environment<'a> {
let ty = checking_data.types.get_type_by_id(current_value);
// TODO temp
- if let Type::SpecialObject(SpecialObjects::Function(..)) = ty {
+ if let Type::SpecialObject(SpecialObject::Function(..)) = ty {
return Ok(VariableWithValue(og_var.clone(), current_value));
} else if let Type::RootPolyType(PolyNature::Open(_)) = ty {
crate::utilities::notify!(
@@ -1124,8 +1045,18 @@ impl<'a> Environment<'a> {
}
}
- pub fn throw_value(&mut self, thrown: TypeId, position: SpanWithSource) {
+ pub fn throw_value(&mut self, thrown: TypeId, position: SpanWithSource, types: &mut TypeStore) {
let final_event = FinalEvent::Throw { thrown, position };
+
+ // WIP
+ let final_return =
+ if let ReturnState::Rolling { under, returned: rolling_returning } = self.info.state {
+ types.new_conditional_type(under, rolling_returning, TypeId::NEVER_TYPE)
+ } else {
+ TypeId::NEVER_TYPE
+ };
+ self.info.state = ReturnState::Finished(final_return);
+
self.info.events.push(final_event.into());
}
@@ -1193,7 +1124,6 @@ impl<'a> Environment<'a> {
// Add the expected return type instead here
// if it fell through to another then it could be bad
- crate::utilities::notify!("Here {:?}", expected);
let expected_return = checking_data.types.new_error_type(expected);
let final_event = FinalEvent::Return {
returned: expected_return,
@@ -1205,8 +1135,20 @@ impl<'a> Environment<'a> {
}
}
- let final_event = FinalEvent::Return { returned, position: returned_position };
- self.info.events.push(final_event.into());
+ {
+ let final_event = FinalEvent::Return { returned, position: returned_position };
+ self.info.events.push(final_event.into());
+
+ // WIP
+ let final_return = if let ReturnState::Rolling { under, returned: rolling_returning } =
+ self.info.state
+ {
+ checking_data.types.new_conditional_type(under, rolling_returning, returned)
+ } else {
+ returned
+ };
+ self.info.state = ReturnState::Finished(final_return);
+ }
}
pub fn add_continue(
@@ -1251,26 +1193,38 @@ impl<'a> Environment<'a> {
///
/// Returns the result of the setter... TODO could return new else
#[allow(clippy::too_many_arguments)]
- pub fn set_property(
+ pub fn set_property_handle_errors(
&mut self,
on: TypeId,
publicity: Publicity,
under: &PropertyKey,
new: TypeId,
- types: &mut TypeStore,
setter_position: SpanWithSource,
- options: &TypeCheckOptions,
- ) -> Result, SetPropertyError> {
- crate::types::properties::set_property(
+ checking_data: &mut CheckingData,
+ ) {
+ // For setters
+ let mut diagnostics = Default::default();
+ let result = crate::types::properties::set_property(
on,
- publicity,
- under,
- PropertyValue::Value(new),
- self,
- &mut CheckThings { debug_types: options.debug_types },
- types,
+ (publicity, under, new),
setter_position,
- )
+ self,
+ (&mut CheckThings { debug_types: checking_data.options.debug_types }, &mut diagnostics),
+ &mut checking_data.types,
+ );
+ diagnostics.append_to(
+ crate::types::calling::CallingContext::Setter,
+ &mut checking_data.diagnostics_container,
+ );
+
+ match result {
+ Ok(()) => {}
+ Err(error) => {
+ checking_data
+ .diagnostics_container
+ .add_error(TypeCheckError::SetPropertyError(error));
+ }
+ }
}
/// `continue` has different behavior to `break` right?
@@ -1325,23 +1279,240 @@ impl<'a> Environment<'a> {
}
None
}
-}
-fn set_property_error_to_type_check_error(
- ctx: &impl InformationChain,
- error: SetPropertyError,
- assignment_span: SpanWithSource,
- types: &TypeStore,
- new: TypeId,
-) -> TypeCheckError<'static> {
- match error {
- SetPropertyError::NotWriteable => TypeCheckError::PropertyNotWriteable(assignment_span),
- SetPropertyError::DoesNotMeetConstraint { property_constraint, reason: _ } => {
- TypeCheckError::AssignmentError(AssignmentError::PropertyConstraint {
- property_constraint,
- value_type: TypeStringRepresentation::from_type_id(new, ctx, types, false),
- assignment_position: assignment_span,
- })
+ pub fn declare_interface<'b, A: crate::ASTImplementation>(
+ &mut self,
+ name: &str,
+ parameters: Option<&'b [A::TypeParameter<'b>]>,
+ extends: Option<&'b [A::TypeAnnotation<'b>]>,
+ types: &mut TypeStore,
+ ) -> Result {
+ // Interface merging
+ {
+ if let Some(id) = self.named_types.get(name) {
+ let ty = types.get_type_by_id(*id);
+ return if let Type::Interface { .. } = ty {
+ Ok(DeclareInterfaceResult::Merging { ty: *id, in_same_context: true })
+ } else {
+ Err(AlreadyExists)
+ };
+ }
+
+ // It is fine that it doesn't necessarily need to be an interface
+ let result = self
+ .parents_iter()
+ .find_map(|env| get_on_ctx!(env.named_types.get(name)))
+ .and_then(|id| {
+ matches!(types.get_type_by_id(*id), Type::Interface { .. }).then_some(*id)
+ });
+
+ if let Some(existing) = result {
+ return Ok(DeclareInterfaceResult::Merging {
+ ty: existing,
+ in_same_context: false,
+ });
+ };
+ }
+
+ let parameters = parameters.map(|parameters| {
+ parameters
+ .iter()
+ .map(|parameter| {
+ let ty = Type::RootPolyType(PolyNature::StructureGeneric {
+ name: A::type_parameter_name(parameter).to_owned(),
+ // This is assigned later
+ extends: TypeId::ANY_TO_INFER_TYPE,
+ });
+ types.register_type(ty)
+ })
+ .collect()
+ });
+
+ let ty = Type::Interface {
+ name: name.to_owned(),
+ parameters,
+ extends: extends.map(|_| TypeId::ANY_TO_INFER_TYPE),
+ };
+ let interface_ty = types.register_type(ty);
+ self.named_types.insert(name.to_owned(), interface_ty);
+ Ok(DeclareInterfaceResult::New(interface_ty))
+ }
+
+ /// Registers the class type
+ pub fn declare_class<'b, A: crate::ASTImplementation>(
+ &mut self,
+ name: &str,
+ type_parameters: Option<&'b [A::TypeParameter<'b>]>,
+ types: &mut TypeStore,
+ ) -> Result {
+ {
+ // Special
+ if let Some(Scope::DefinitionModule { .. }) =
+ self.context_type.as_syntax().map(|s| &s.scope)
+ {
+ match name {
+ "Array" => {
+ return Ok(TypeId::ARRAY_TYPE);
+ }
+ "Promise" => {
+ return Ok(TypeId::PROMISE_TYPE);
+ }
+ "String" => {
+ return Ok(TypeId::STRING_TYPE);
+ }
+ "Number" => {
+ return Ok(TypeId::NUMBER_TYPE);
+ }
+ "Boolean" => {
+ return Ok(TypeId::BOOLEAN_TYPE);
+ }
+ "Function" => {
+ return Ok(TypeId::FUNCTION_TYPE);
+ }
+ "ImportMeta" => {
+ return Ok(TypeId::IMPORT_META);
+ }
+ _ => {}
+ }
+ }
+ }
+
+ let type_parameters = type_parameters.map(|type_parameters| {
+ type_parameters
+ .iter()
+ .map(|parameter| {
+ let ty = Type::RootPolyType(PolyNature::StructureGeneric {
+ name: A::type_parameter_name(parameter).to_owned(),
+ //A::parameter_constrained(parameter),
+ // TODO
+ extends: TypeId::ANY_TO_INFER_TYPE,
+ });
+ types.register_type(ty)
+ })
+ .collect()
+ });
+
+ let ty = Type::Class { name: name.to_owned(), type_parameters };
+ let class_type = types.register_type(ty);
+ self.named_types.insert(name.to_owned(), class_type);
+ // TODO duplicates
+
+ Ok(class_type)
+ }
+
+ pub fn declare_alias<'b, A: crate::ASTImplementation>(
+ &mut self,
+ name: &str,
+ parameters: Option<&'b [A::TypeParameter<'b>]>,
+ _position: Span,
+ types: &mut TypeStore,
+ ) -> Result {
+ let parameters = parameters.map(|parameters| {
+ parameters
+ .iter()
+ .map(|parameter| {
+ let ty = Type::RootPolyType(PolyNature::StructureGeneric {
+ name: A::type_parameter_name(parameter).to_owned(),
+ // Set later for recursion
+ extends: TypeId::ANY_TO_INFER_TYPE,
+ });
+ types.register_type(ty)
+ })
+ .collect()
+ });
+
+ let ty = Type::AliasTo { to: TypeId::ANY_TO_INFER_TYPE, name: name.to_owned(), parameters };
+ let alias_ty = types.register_type(ty);
+ let existing_type = self.named_types.insert(name.to_owned(), alias_ty);
+
+ if existing_type.is_none() {
+ Ok(alias_ty)
+ } else {
+ Err(AlreadyExists)
}
}
+
+ // TODO copy this logic for interface and class
+ pub fn register_alias<'b, U: crate::ReadFromFS, A: crate::ASTImplementation>(
+ &mut self,
+ on: TypeId,
+ ast_parameters: Option<&'b [A::TypeParameter<'b>]>,
+ to: &'b A::TypeAnnotation<'b>,
+ position: Span,
+ checking_data: &mut CheckingData,
+ ) {
+ if on == TypeId::ERROR_TYPE {
+ return;
+ }
+
+ let new_to = if let Type::AliasTo { to: _, parameters: Some(parameters), name: _ } =
+ checking_data.types.get_type_by_id(on)
+ {
+ let mut sub_environment = self.new_lexical_environment(Scope::TypeAlias);
+ let parameters = parameters.clone();
+ for parameter in parameters.iter().copied() {
+ let Type::RootPolyType(PolyNature::StructureGeneric { name, .. }) =
+ checking_data.types.get_type_by_id(parameter)
+ else {
+ unreachable!()
+ };
+ sub_environment.named_types.insert(name.clone(), parameter);
+ }
+ for (parameter, ast_parameter) in parameters.into_iter().zip(ast_parameters.unwrap()) {
+ let new_to = A::synthesise_type_parameter_extends(
+ ast_parameter,
+ &mut sub_environment,
+ checking_data,
+ );
+ checking_data.types.update_generic_extends(parameter, new_to);
+ }
+ let ty = A::synthesise_type_annotation(to, &mut sub_environment, checking_data);
+ // TODO temp as object types use the same environment.properties representation
+ {
+ let crate::LocalInformation { current_properties, prototypes, .. } =
+ sub_environment.info;
+ self.info.current_properties.extend(current_properties);
+ self.info.prototypes.extend(prototypes);
+ }
+
+ // TODO check cycles
+ ty
+ } else {
+ let ty = A::synthesise_type_annotation(to, self, checking_data);
+
+ // Cycle checking
+ let disjoint = crate::types::disjoint::types_are_disjoint(
+ ty,
+ on,
+ &mut Vec::new(),
+ self,
+ &checking_data.types,
+ );
+
+ if disjoint {
+ ty
+ } else {
+ checking_data.diagnostics_container.add_error(TypeCheckError::CyclicTypeAlias {
+ position: position.with_source(self.get_source()),
+ });
+ TypeId::ERROR_TYPE
+ }
+ };
+
+ checking_data.types.update_alias(on, new_to);
+ }
+
+ /// For functions and classes
+ pub(crate) fn register_constructable_function(
+ &mut self,
+ referenced_in_scope_as: TypeId,
+ function: crate::FunctionId,
+ ) {
+ self.info.events.push(Event::Miscellaneous(
+ crate::events::MiscellaneousEvents::CreateConstructor {
+ referenced_in_scope_as,
+ function,
+ },
+ ));
+ }
}
diff --git a/checker/src/context/information.rs b/checker/src/context/information.rs
index 51212f22..480eefbc 100644
--- a/checker/src/context/information.rs
+++ b/checker/src/context/information.rs
@@ -1,16 +1,19 @@
use source_map::SpanWithSource;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
use crate::{
events::{Event, RootReference},
- features::functions::{ClosureId, ThisValue},
+ features::functions::ClosureId,
types::{
+ calling::ThisValue,
properties::{PropertyKey, Publicity},
TypeStore,
},
PropertyValue, Type, TypeId, VariableId,
};
+pub type Properties = Vec<(Publicity, PropertyKey<'static>, PropertyValue)>;
+
/// Things that are currently true or have happened
#[derive(Debug, Default, binary_serialize_derive::BinarySerializable)]
pub struct LocalInformation {
@@ -20,53 +23,104 @@ pub struct LocalInformation {
/// This can be not have a value if not defined
pub(crate) variable_current_value: HashMap,
- pub(crate) current_properties:
- HashMap, PropertyValue)>>,
+ pub(crate) current_properties: HashMap,
/// Can be modified (unfortunately) so here
pub(crate) prototypes: HashMap,
pub(crate) closure_current_values: HashMap<(ClosureId, RootReference), TypeId>,
- pub(crate) configurable: HashMap<(TypeId, TypeId), TypeId>,
- pub(crate) enumerable: HashMap<(TypeId, TypeId), TypeId>,
- pub(crate) writable: HashMap<(TypeId, TypeId), TypeId>,
- pub(crate) frozen: HashMap,
+ /// Not writeable, `TypeError: Cannot add property t, object is not extensible`. TODO conditional ?
+ pub(crate) frozen: HashSet,
/// Object type (LHS), must always be RHS
///
/// *not quite the best place, but used in [`InformationChain`]*
pub(crate) object_constraints: HashMap,
+ pub(crate) state: ReturnState,
+
/// For super calls etc
///
/// TODO not great that this has to be Option to satisfy Default
pub(crate) value_of_this: ThisValue,
}
+#[derive(Debug, Default, binary_serialize_derive::BinarySerializable, Clone)]
+pub(crate) enum ReturnState {
+ #[default]
+ Continued,
+ Rolling {
+ under: TypeId,
+ returned: TypeId,
+ },
+ Finished(TypeId),
+}
+
+impl ReturnState {
+ pub(crate) fn is_finished(&self) -> bool {
+ matches!(self, ReturnState::Finished(..))
+ }
+
+ pub(crate) fn get_returned(self, types: &mut TypeStore) -> TypeId {
+ match self {
+ ReturnState::Continued => TypeId::UNDEFINED_TYPE,
+ ReturnState::Rolling { under, returned } => {
+ types.new_conditional_type(under, returned, TypeId::UNDEFINED_TYPE)
+ }
+ ReturnState::Finished(ty) => ty,
+ }
+ }
+
+ pub(crate) fn append(&mut self, new: ReturnState) {
+ match self {
+ ReturnState::Continued => *self = new,
+ ReturnState::Rolling { .. } => match new {
+ ReturnState::Continued => todo!(),
+ ReturnState::Rolling { .. } => todo!(),
+ new @ ReturnState::Finished(_) => {
+ crate::utilities::notify!("Warning overwriting conditional");
+ *self = new;
+ }
+ },
+ ReturnState::Finished(_) => todo!(),
+ }
+ }
+}
+
impl LocalInformation {
- /// TODO temp
- pub fn register_property(
+ /// For interfaces only
+ pub fn register_property_on_type(
&mut self,
on: TypeId,
publicity: Publicity,
under: PropertyKey<'static>,
to: PropertyValue,
- register_setter_event: bool,
+ ) {
+ self.current_properties.entry(on).or_default().push((publicity, under, to));
+ }
+ pub fn register_property(
+ &mut self,
+ on: TypeId,
+ publicity: Publicity,
+ under: PropertyKey<'static>,
+ value: PropertyValue,
position: SpanWithSource,
) {
- // crate::utilities::notify!("Registering {:?} {:?} {:?}", on, under, to);
- self.current_properties.entry(on).or_default().push((publicity, under.clone(), to.clone()));
- if register_setter_event {
- self.events.push(Event::Setter {
+ self.current_properties.entry(on).or_default().push((
+ publicity,
+ under.clone(),
+ value.clone(),
+ ));
+ self.events.push(Event::Miscellaneous(
+ crate::events::MiscellaneousEvents::RegisterProperty {
on,
under,
- new: to,
- initialization: true,
+ value,
publicity,
position,
- });
- }
+ },
+ ));
}
// /// This is how invocation contexts register throws...
@@ -79,6 +133,31 @@ impl LocalInformation {
&self.events
}
+ /// Use `features::delete_property`
+ pub(crate) fn delete_property(
+ &mut self,
+ on: TypeId,
+ (publicity, key): (Publicity, PropertyKey<'static>),
+ position: SpanWithSource,
+ option: Option,
+ ) {
+ // on_default() okay because might be in a nested context.
+ // entry empty does not mean no properties, just no properties set on this level
+ self.current_properties.entry(on).or_default().push((
+ publicity,
+ key.clone(),
+ PropertyValue::Deleted,
+ ));
+
+ self.events.push(Event::Miscellaneous(crate::events::MiscellaneousEvents::Delete {
+ on,
+ publicity,
+ under: key,
+ into: option,
+ position,
+ }));
+ }
+
pub(crate) fn new_object(
&mut self,
prototype: Option,
@@ -126,9 +205,6 @@ impl LocalInformation {
self.current_properties.extend(other.current_properties);
self.prototypes.extend(other.prototypes);
self.closure_current_values.extend(other.closure_current_values);
- self.configurable.extend(other.configurable);
- self.enumerable.extend(other.enumerable);
- self.writable.extend(other.writable);
self.frozen.extend(other.frozen);
}
@@ -142,24 +218,12 @@ impl LocalInformation {
.extend(other.current_properties.iter().map(|(l, r)| (*l, r.clone())));
self.closure_current_values
.extend(other.closure_current_values.iter().map(|(l, r)| (l.clone(), *r)));
- self.configurable.extend(other.configurable.iter().clone());
- self.enumerable.extend(other.enumerable.iter().clone());
- self.writable.extend(other.writable.iter().clone());
self.frozen.extend(other.frozen.iter().clone());
}
#[must_use]
pub fn is_halted(&self) -> bool {
- if let Some(last) = self.events.last() {
- if let Event::FinalEvent(_) = last {
- true
- } else {
- crate::utilities::notify!("TODO ifs others");
- false
- }
- } else {
- false
- }
+ self.state.is_finished()
}
}
@@ -173,6 +237,17 @@ impl InformationChain for LocalInformation {
}
}
+pub struct ModuleInformation<'a> {
+ pub top: &'a LocalInformation,
+ pub module: &'a LocalInformation,
+}
+
+impl<'a> InformationChain for ModuleInformation<'a> {
+ fn get_chain_of_info(&self) -> impl Iterator- {
+ IntoIterator::into_iter([self.top, self.module])
+ }
+}
+
pub(crate) fn get_value_of_constant_import_variable(
variable: VariableId,
info: &impl InformationChain,
@@ -193,15 +268,23 @@ pub fn merge_info(
) {
let truthy_events = truthy.events.len() as u32;
let otherwise_events = otherwise.as_ref().map_or(0, |f| f.events.len() as u32);
- onto.events.push(Event::Conditionally { condition, truthy_events, otherwise_events, position });
- onto.events.append(&mut truthy.events);
- if let Some(ref mut otherwise) = otherwise {
- crate::utilities::notify!("truthy {:?} otherwise {:?}", truthy.events, otherwise.events);
- onto.events.append(&mut otherwise.events);
- }
+ if truthy_events + otherwise_events != 0 {
+ onto.events.push(Event::Conditionally {
+ condition,
+ truthy_events,
+ otherwise_events,
+ position,
+ });
+
+ onto.events.append(&mut truthy.events);
+ if let Some(ref mut otherwise) = otherwise {
+ // crate::utilities::notify!("truthy events={:?}, otherwise events={:?}", truthy.events, otherwise.events);
+ onto.events.append(&mut otherwise.events);
+ }
- onto.events.push(Event::EndOfControlFlow(truthy_events + otherwise_events));
+ onto.events.push(Event::EndOfControlFlow(truthy_events + otherwise_events));
+ }
// TODO don't need to do above some scope
for (var, true_value) in truthy.variable_current_value {
@@ -232,5 +315,41 @@ pub fn merge_info(
onto.current_properties.extend(otherwise.current_properties.drain());
}
+ // TODO I think these are okay
+ onto.state = match (
+ truthy.state,
+ otherwise.as_ref().map_or(ReturnState::Continued, |o| o.state.clone()),
+ ) {
+ (ReturnState::Continued, ReturnState::Continued) => ReturnState::Continued,
+ (ReturnState::Continued, ReturnState::Rolling { .. }) => todo!(),
+ (ReturnState::Continued, ReturnState::Finished(returned)) => {
+ ReturnState::Rolling { under: types.new_logical_negation_type(condition), returned }
+ }
+ (ReturnState::Rolling { under, returned }, ReturnState::Continued) => {
+ ReturnState::Rolling { under: types.new_logical_and_type(condition, under), returned }
+ }
+ (
+ ReturnState::Rolling { under: truthy_under, returned: truthy_returned },
+ ReturnState::Rolling { under: otherwise_under, returned: otherwise_returned },
+ ) => {
+ let under = types.new_logical_or_type(truthy_under, otherwise_under);
+ let returned =
+ types.new_conditional_type(condition, truthy_returned, otherwise_returned);
+ ReturnState::Rolling { under, returned }
+ }
+ (ReturnState::Rolling { .. }, ReturnState::Finished(_)) => todo!(),
+ (ReturnState::Finished(returned), ReturnState::Continued) => {
+ ReturnState::Rolling { under: condition, returned }
+ }
+ (ReturnState::Finished(_), ReturnState::Rolling { .. }) => todo!(),
+ (ReturnState::Finished(truthy_return), ReturnState::Finished(otherwise_return)) => {
+ ReturnState::Finished(types.new_conditional_type(
+ condition,
+ truthy_return,
+ otherwise_return,
+ ))
+ }
+ };
+
// TODO set more information? an exit condition?
}
diff --git a/checker/src/context/invocation.rs b/checker/src/context/invocation.rs
index e8cb8b90..b7218ade 100644
--- a/checker/src/context/invocation.rs
+++ b/checker/src/context/invocation.rs
@@ -1,7 +1,12 @@
//! When a function is called (or a group of events like function such as a iteration block) it creates a mini-environment for which events are applied into
-use super::information::LocalInformation;
-use crate::{events::ApplicationResult, types::TypeStore, Environment, FunctionId, TypeId};
+use source_map::SpanWithSource;
+
+use super::LocalInformation;
+use crate::{
+ context::information::merge_info, events::ApplicationResult, types::TypeStore, Environment,
+ FunctionId, TypeId,
+};
/// For anything that might involve a call, including gets, sets and actual calls
pub trait CallCheckingBehavior {
@@ -71,6 +76,7 @@ pub(crate) enum InvocationKind {
AlwaysTrue,
Function(FunctionId),
LoopIteration,
+ Unknown,
}
impl CallCheckingBehavior for InvocationContext {
@@ -117,6 +123,21 @@ impl InvocationContext {
InvocationContext(Vec::new())
}
+ pub(crate) fn in_unknown(&self) -> bool {
+ self.0.iter().any(|c| matches!(c, InvocationKind::Unknown))
+ }
+
+ /// WIP
+ pub(crate) fn new_unknown_target(
+ &mut self,
+ cb: impl for<'a> FnOnce(&'a mut InvocationContext) -> T,
+ ) -> T {
+ self.0.push(InvocationKind::Unknown);
+ let result = cb(self);
+ self.0.pop();
+ result
+ }
+
fn new_conditional_target(
&mut self,
cb: impl for<'a> FnOnce(&'a mut InvocationContext) -> T,
@@ -168,7 +189,7 @@ impl InvocationContext {
&mut self,
top_environment: &mut Environment,
types: &mut TypeStore,
- _condition: TypeId,
+ (condition, condition_position): (TypeId, SpanWithSource),
(input_left, input_right): (T, T),
mut data: I,
cb: impl for<'a> Fn(
@@ -179,12 +200,12 @@ impl InvocationContext {
&'a mut I,
) -> R,
) -> (I, (R, R)) {
- let (_truthy_info, truthy_result) =
+ let (truthy_info, truthy_result) =
self.new_conditional_target(|target: &mut InvocationContext| {
cb(top_environment, types, target, input_left, &mut data)
});
- let (_otherwise_info, otherwise_result) =
+ let (otherwise_info, otherwise_result) =
self.new_conditional_target(|target: &mut InvocationContext| {
cb(top_environment, types, target, input_right, &mut data)
});
@@ -192,10 +213,44 @@ impl InvocationContext {
// TODO all things that are
// - variable and property values (these aren't read from events)
// - immutable, mutable, prototypes etc
- let _info = self.get_latest_info(top_environment);
+ // let info = self.get_latest_info(top_environment);
- // TODO
- // merge_info(top_environment, info, condition, truthy_info, Some(otherwise_info), types);
+ if self.0.iter().any(|x| matches!(x, InvocationKind::Conditional(_))) {
+ todo!("nested, get latest")
+ // let local_information = &mut top_environment.info;
+ // match top_environment.context_type.parent {
+ // crate::GeneralContext::Syntax(env) => {
+ // merge_info(
+ // env,
+ // local_information,
+ // condition,
+ // truthy_info,
+ // Some(otherwise_info),
+ // types,
+ // condition_position,
+ // );
+ // }
+ // crate::GeneralContext::Root(_) => todo!(),
+ // }
+ } else {
+ let local_information = &mut top_environment.info;
+ match top_environment.context_type.parent {
+ crate::GeneralContext::Syntax(env) => {
+ merge_info(
+ env,
+ local_information,
+ condition,
+ truthy_info,
+ Some(otherwise_info),
+ types,
+ condition_position,
+ );
+ }
+ crate::GeneralContext::Root(_) => {
+ crate::utilities::notify!("Top environment is root?");
+ }
+ }
+ }
(data, (truthy_result, otherwise_result))
}
diff --git a/checker/src/context/mod.rs b/checker/src/context/mod.rs
index 1f809017..f501c254 100644
--- a/checker/src/context/mod.rs
+++ b/checker/src/context/mod.rs
@@ -10,33 +10,26 @@ mod root;
pub(crate) use invocation::CallCheckingBehavior;
pub use root::RootContext;
-use source_map::{Span, SpanWithSource};
+use source_map::SpanWithSource;
use crate::{
context::environment::ExpectedReturnType,
- diagnostics::{
- CannotRedeclareVariable, TypeCheckError, TypeCheckWarning, TypeStringRepresentation, TDZ,
- },
+ diagnostics::{CannotRedeclareVariable, TypeCheckError, TypeStringRepresentation, TDZ},
events::RootReference,
features::{
assignments::Reference,
functions::ClosureChain,
- objects::{Proxy, SpecialObjects},
+ objects::SpecialObject,
variables::{VariableMutability, VariableOrImport},
},
- types::{
- generics::generic_type_arguments::GenericArguments, FunctionType, PolyNature, Type, TypeId,
- TypeStore,
- },
- CheckingData, DiagnosticsContainer, FunctionId, VariableId,
+ types::{FunctionType, PolyNature, Type, TypeId, TypeStore},
+ CheckingData, DiagnosticsContainer, FunctionId, TypeMappings, VariableId,
};
-use self::{
- environment::{DynamicBoundaryKind, FunctionScope},
- information::{InformationChain, LocalInformation},
-};
+use self::environment::{DynamicBoundaryKind, FunctionScope};
pub use environment::Scope;
pub(crate) use environment::Syntax;
+pub use information::{InformationChain, LocalInformation, Properties};
use std::{
collections::{
@@ -173,7 +166,7 @@ pub struct Context {
pub(crate) can_reference_this: CanReferenceThis,
/// When a objects `TypeId` is in here getting a property returns a constructor rather than
- pub possibly_mutated_objects: HashSet,
+ pub possibly_mutated_objects: HashMap,
pub possibly_mutated_variables: HashSet,
// pub (crate) info: info,
@@ -184,6 +177,8 @@ pub struct VariableRegisterArguments {
pub constant: bool,
pub space: Option,
pub initial_value: Option,
+ /// for `var` declarations
+ pub allow_reregistration: bool,
}
#[derive(Debug, Clone, binary_serialize_derive::BinarySerializable)]
@@ -203,7 +198,7 @@ impl Context {
&mut self,
name: &'b str,
declared_at: SpanWithSource,
- VariableRegisterArguments { constant, initial_value, space }: VariableRegisterArguments,
+ VariableRegisterArguments { constant, initial_value, space, allow_reregistration }: VariableRegisterArguments,
record_event: bool,
) -> Result<(), CannotRedeclareVariable<'b>> {
let id = VariableId(declared_at.source, declared_at.start);
@@ -214,31 +209,43 @@ impl Context {
VariableMutability::Mutable { reassignment_constraint: space }
};
- let variable = VariableOrImport::Variable { declared_at, mutability, context: None };
+ let variable = VariableOrImport::Variable {
+ declared_at,
+ mutability,
+ context: None,
+ allow_reregistration,
+ };
- let existing = match self.variables.entry(name.to_owned()) {
- Entry::Occupied(_) => true,
+ let entry = self.variables.entry(name.to_owned());
+ let existing_that_can_be_rewritten = match entry {
+ Entry::Occupied(e) => match e.get() {
+ VariableOrImport::Variable { allow_reregistration, .. } => !*allow_reregistration,
+ VariableOrImport::MutableImport { .. }
+ | VariableOrImport::ConstantImport { .. } => true,
+ },
Entry::Vacant(vacant) => {
vacant.insert(variable);
+ self.variable_names.insert(id, name.to_owned());
false
}
};
- self.variable_names.insert(id, name.to_owned());
-
- if let Some(initial_value) = initial_value {
- self.info.variable_current_value.insert(id, initial_value);
- }
+ // Still set data regardless
+ {
+ if let Some(initial_value) = initial_value {
+ self.info.variable_current_value.insert(id, initial_value);
+ }
- if record_event {
- self.info.events.push(crate::events::Event::RegisterVariable {
- name: name.to_owned(),
- position: declared_at,
- initial_value,
- });
+ if record_event {
+ self.info.events.push(crate::events::Event::RegisterVariable {
+ name: name.to_owned(),
+ position: declared_at,
+ initial_value,
+ });
+ }
}
- if existing {
+ if existing_that_can_be_rewritten {
Err(CannotRedeclareVariable { name })
} else {
Ok(())
@@ -251,9 +258,23 @@ impl Context {
argument: VariableRegisterArguments,
declared_at: SpanWithSource,
diagnostics_container: &mut DiagnosticsContainer,
+ type_mappings: &mut TypeMappings,
record_event: bool,
) {
- if let Err(_err) = self.register_variable(name, declared_at, argument, record_event) {
+ if argument.allow_reregistration {
+ if let Some(existing) = self.variables.get(name) {
+ type_mappings.var_aliases.insert(declared_at.start, existing.get_id());
+ }
+ }
+
+ if let Some(reassignment_constraint) = argument.space {
+ let id = crate::VariableId(self.get_source(), declared_at.start);
+ type_mappings.variables_to_constraints.0.insert(id, reassignment_constraint);
+ }
+
+ let register_variable = self.register_variable(name, declared_at, argument, record_event);
+
+ if let Err(CannotRedeclareVariable { name }) = register_variable {
diagnostics_container.add_error(TypeCheckError::CannotRedeclareVariable {
name: name.to_owned(),
position: declared_at,
@@ -461,21 +482,19 @@ impl Context {
}
#[allow(clippy::map_flatten)]
- pub fn get_all_variable_names(&self) -> Vec<&str> {
+ pub fn get_all_variable_names(&self) -> impl Iterator
- {
self.parents_iter()
- .map(|env| get_on_ctx!(env.variables.keys()).collect::>())
+ .map(|env| get_on_ctx!(env.variables.keys()))
.flatten()
.map(AsRef::as_ref)
- .collect::>()
}
#[allow(clippy::map_flatten)]
- pub fn get_all_named_types(&self) -> Vec<&str> {
+ pub fn get_all_named_types(&self) -> impl Iterator
- {
self.parents_iter()
- .map(|env| get_on_ctx!(env.named_types.keys()).collect::>())
+ .map(|env| get_on_ctx!(env.named_types.keys()))
.flatten()
.map(AsRef::as_ref)
- .collect::>()
}
pub(crate) fn get_variable_name(&self, id: VariableId) -> &str {
@@ -692,6 +711,7 @@ impl Context {
None
} else if self.context_type.get_parent().is_some() {
self.info.events.append(&mut info.events);
+ self.info.state.append(info.state);
None
} else {
Some((info, Default::default()))
@@ -717,6 +737,10 @@ impl Context {
})
}
+ /// ```ts
+ /// (...)
+ /// ^
+ /// ```
pub fn new_explicit_type_parameter(
&mut self,
name: &str,
@@ -727,7 +751,7 @@ impl Context {
let ty = Type::RootPolyType(PolyNature::FunctionGeneric {
name: name.to_owned(),
// TODO this is fixed!!
- eager_fixed: constraint_type.unwrap_or(TypeId::ANY_TYPE),
+ extends: constraint_type.unwrap_or(TypeId::ANY_TYPE),
});
let ty = types.register_type(ty);
@@ -753,184 +777,17 @@ impl Context {
if let Some(val) = self.get_type_from_name(name) {
val
} else {
- checking_data.diagnostics_container.add_error(TypeCheckError::CouldNotFindType(
- name,
- self.get_all_named_types(),
- pos,
- ));
-
- TypeId::ERROR_TYPE
- }
- }
-
- /// TODO extends
- pub fn register_interface<'a, U: crate::ReadFromFS, A: crate::ASTImplementation>(
- &mut self,
- name: &str,
- nominal: bool,
- parameters: Option<&'a [A::TypeParameter<'a>]>,
- _extends: Option<&'a [A::TypeAnnotation<'a>]>,
- position: SpanWithSource,
- checking_data: &mut CheckingData,
- ) -> TypeId {
- // Interface merging
- {
- let existing = if let Some(id) = self.named_types.get(name) {
- if let Type::Interface { .. } = checking_data.types.get_type_by_id(*id) {
- checking_data
- .diagnostics_container
- .add_warning(TypeCheckWarning::MergingInterfaceInSameContext { position });
-
- Some(*id)
- } else {
- checking_data.diagnostics_container.add_error(
- TypeCheckError::TypeAlreadyDeclared { name: name.to_owned(), position },
- );
- return TypeId::ERROR_TYPE;
- }
- } else {
- self.parents_iter().find_map(|env| get_on_ctx!(env.named_types.get(name))).and_then(
- |id| {
- matches!(checking_data.types.get_type_by_id(*id), Type::Interface { .. })
- .then_some(*id)
- },
- )
- };
-
- if let Some(existing) = existing {
- return existing;
+ let possibles = {
+ let mut possibles =
+ crate::get_closest(self.get_all_named_types(), name).unwrap_or(vec![]);
+ possibles.sort_unstable();
+ possibles
};
- }
+ checking_data
+ .diagnostics_container
+ .add_error(TypeCheckError::CouldNotFindType(name, possibles, pos));
- let parameters = parameters.map(|parameters| {
- parameters
- .iter()
- .map(|parameter| {
- let ty = Type::RootPolyType(PolyNature::FunctionGeneric {
- name: A::type_parameter_name(parameter).to_owned(),
- // This is assigned later
- eager_fixed: TypeId::ANY_TYPE,
- });
- checking_data.types.register_type(ty)
- })
- .collect()
- });
-
- let ty = Type::Interface { name: name.to_owned(), nominal, parameters };
- let interface_ty = checking_data.types.register_type(ty);
- self.named_types.insert(name.to_owned(), interface_ty);
- interface_ty
- }
-
- /// Registers the class type
- pub fn register_class<'a, A: crate::ASTImplementation>(
- &mut self,
- name: &str,
- parameters: Option<&'a [A::TypeParameter<'a>]>,
- _extends: Option<&'a A::Expression<'a>>,
- types: &mut TypeStore,
- ) -> TypeId {
- {
- // Special
- if let Some(Scope::DefinitionModule { .. }) =
- self.context_type.as_syntax().map(|s| &s.scope)
- {
- match name {
- "Array" => {
- return TypeId::ARRAY_TYPE;
- }
- "Promise" => {
- return TypeId::PROMISE_TYPE;
- }
- "String" => {
- return TypeId::STRING_TYPE;
- }
- "Number" => {
- return TypeId::NUMBER_TYPE;
- }
- "Boolean" => {
- return TypeId::BOOLEAN_TYPE;
- }
- "ImportMeta" => {
- return TypeId::IMPORT_META;
- }
- _ => {}
- }
- }
- }
-
- let parameters = parameters.map(|parameters| {
- parameters
- .iter()
- .map(|parameter| {
- let ty = Type::RootPolyType(PolyNature::StructureGeneric {
- name: A::type_parameter_name(parameter).to_owned(),
- constrained: A::parameter_constrained(parameter),
- });
- types.register_type(ty)
- })
- .collect()
- });
-
- let ty = Type::Class { name: name.to_owned(), parameters };
- let interface_ty = types.register_type(ty);
- self.named_types.insert(name.to_owned(), interface_ty);
- interface_ty
- }
-
- pub fn new_alias<'a, U: crate::ReadFromFS, A: crate::ASTImplementation>(
- &mut self,
- name: &str,
- parameters: Option<&'a [A::TypeParameter<'a>]>,
- to: &'a A::TypeAnnotation<'a>,
- position: Span,
- checking_data: &mut CheckingData,
- ) -> TypeId {
- // Doing this as may be a bit faster maybe?
- let mut env = self.new_lexical_environment(Scope::TypeAlias);
-
- let (parameters, to) = if let Some(parameters) = parameters {
- let parameters = parameters
- .iter()
- .map(|parameter| {
- let name = A::type_parameter_name(parameter).to_owned();
- let ty = Type::RootPolyType(PolyNature::FunctionGeneric {
- name: name.clone(),
- eager_fixed: TypeId::ANY_TYPE,
- });
- let ty = checking_data.types.register_type(ty);
- // TODO declare type
- env.named_types.insert(name, ty);
- ty
- })
- .collect();
-
- let to = A::synthesise_type_annotation(to, &mut env, checking_data);
- (Some(parameters), to)
- } else {
- // TODO should just use self
- let to = A::synthesise_type_annotation(to, &mut env, checking_data);
- (None, to)
- };
-
- // TODO temp as object types use the same environment.properties representation
- env.info.current_properties.into_iter().for_each(|(t, mut props)| {
- self.info.current_properties.entry(t).or_default().append(&mut props);
- });
-
- // Works as an alias
- let ty = Type::AliasTo { to, name: name.to_owned(), parameters };
- let alias_ty = checking_data.types.register_type(ty);
- let existing_type = self.named_types.insert(name.to_owned(), alias_ty);
-
- if existing_type.is_some() {
- checking_data.diagnostics_container.add_error(TypeCheckError::TypeAlreadyDeclared {
- name: name.to_owned(),
- position: position.with_source(self.get_source()),
- });
TypeId::ERROR_TYPE
- } else {
- alias_ty
}
}
@@ -939,16 +796,6 @@ impl Context {
id: VariableId,
value_ty: TypeId,
) {
- if let Some(_closed_over_references) =
- self.context_type.as_syntax().map(|s| &s.closed_over_references)
- {
- // crate::utilities::notify!(
- // "is {:?} closed over {:?}",
- // id,
- // closed_over_references.get(&RootReference::Variable(id))
- // );
- }
-
self.info.variable_current_value.insert(id, value_ty);
}
@@ -964,13 +811,18 @@ impl Context {
let id = crate::VariableId(declared_at.source, declared_at.start);
let kind = VariableMutability::Constant;
- let variable = VariableOrImport::Variable { declared_at, mutability: kind, context };
+ let variable = VariableOrImport::Variable {
+ declared_at,
+ mutability: kind,
+ context,
+ allow_reregistration: false,
+ };
let entry = self.variables.entry(name.to_owned());
if let Entry::Vacant(vacant) = entry {
vacant.insert(variable);
// TODO unsure ...
- let ty = if let Type::SpecialObject(SpecialObjects::Function(..)) =
+ let ty = if let Type::SpecialObject(SpecialObject::Function(..)) =
types.get_type_by_id(variable_ty)
{
variable_ty
@@ -1044,6 +896,7 @@ impl Context {
})
}
+ /// WIP for tree shaking
pub(crate) fn is_always_run(&self) -> bool {
!self.parents_iter().any(|ctx| {
if let GeneralContext::Syntax(s) = ctx {
@@ -1122,6 +975,16 @@ impl Context {
}
})
}
+
+ pub(crate) fn get_prototype(&self, on: TypeId) -> TypeId {
+ if let Some(prototype) = self.info.prototypes.get(&on) {
+ *prototype
+ } else if let Some(parent) = self.context_type.get_parent() {
+ get_on_ctx!(parent.get_prototype(on))
+ } else {
+ TypeId::OBJECT_TYPE
+ }
+ }
}
pub enum AssignmentError {
@@ -1134,9 +997,9 @@ pub enum AssignmentError {
/// Covers both assignment and declaration
DoesNotMeetConstraint {
variable_type: TypeStringRepresentation,
- variable_site: SpanWithSource,
+ variable_position: SpanWithSource,
value_type: TypeStringRepresentation,
- value_site: SpanWithSource,
+ value_position: SpanWithSource,
},
PropertyConstraint {
property_constraint: TypeStringRepresentation,
@@ -1146,45 +1009,6 @@ pub enum AssignmentError {
TDZ(TDZ),
}
-/// Wraps logic
-#[derive(Debug, Clone)]
-pub enum Logical {
- Pure(T),
- /// Note this uses [`PossibleLogical`] rather than [`Logical`]
- Or {
- /// This can be [`TypeId::BOOLEAN_TYPE`] for unknown left-right-ness
- condition: TypeId,
- left: Box>,
- right: Box>,
- },
- Implies {
- on: Box,
- antecedent: GenericArguments,
- },
-}
-
-#[derive(Debug, Clone)]
-pub enum MissingOrToCalculate {
- /// Doesn't contain request
- Missing,
- /// From [`TypeId::ERROR_TYPE`]
- Error,
- /// From [`TypeId::ANY_TYPE`]
- Infer { on: TypeId },
- /// Proxies require extra work in some cases
- Proxy(Proxy),
-}
-
-pub type PossibleLogical = Result, MissingOrToCalculate>;
-
-pub enum SetPropertyError {
- NotWriteable,
- DoesNotMeetConstraint {
- property_constraint: TypeStringRepresentation,
- reason: crate::types::subtyping::NonEqualityReason,
- },
-}
-
/// TODO mutable let imports
pub(crate) fn get_value_of_variable(
info: &impl InformationChain,
diff --git a/checker/src/context/root.rs b/checker/src/context/root.rs
index 221f626d..4c6bf909 100644
--- a/checker/src/context/root.rs
+++ b/checker/src/context/root.rs
@@ -1,11 +1,14 @@
-use super::{ClosedOverReferencesInScope, Context, ContextId, ContextType};
+use super::{
+ ClosedOverReferencesInScope, Context, ContextId, ContextType, Environment, GeneralContext,
+ LocalInformation,
+};
use crate::{
features::{
modules::{Exported, SynthesisedModule},
variables::VariableOrImport,
},
types::TypeId,
- CheckingData, Environment, GeneralContext,
+ CheckingData,
};
use source_map::SourceId;
use std::{collections::HashMap, iter::FromIterator, mem};
@@ -33,8 +36,6 @@ impl ContextType for Root {
}
}
-const _CONTEXT_FILE_HEADER: &[u8] = b"EZNO\0CONTEXT\0FILE";
-
impl RootContext {
/// Merges two [`RootEnvironments`]. May be used for multiple `.d.ts` files
pub(crate) fn _union(&mut self, other: Self) {
@@ -68,16 +69,29 @@ impl RootContext {
("object".to_owned(), TypeId::OBJECT_TYPE),
("Literal".to_owned(), TypeId::LITERAL_RESTRICTION),
("Readonly".to_owned(), TypeId::READONLY_RESTRICTION),
+ ("Exclusive".to_owned(), TypeId::EXCLUSIVE_RESTRICTION),
+ ("Uppercase".to_owned(), TypeId::STRING_UPPERCASE),
+ ("Lowercase".to_owned(), TypeId::STRING_LOWERCASE),
+ ("Capitalize".to_owned(), TypeId::STRING_CAPITALIZE),
+ ("Uncapitalize".to_owned(), TypeId::STRING_UNCAPITALIZE),
+ ("NoInfer".to_owned(), TypeId::NO_INFER),
+ ("LessThan".to_owned(), TypeId::LESS_THAN),
+ ("GreaterThan".to_owned(), TypeId::GREATER_THAN),
+ ("MultipleOf".to_owned(), TypeId::MULTIPLE_OF),
+ ("NotNotANumber".to_owned(), TypeId::NOT_NOT_A_NUMBER),
+ ("Not".to_owned(), TypeId::NOT_RESTRICTION),
+ ("CaseInsensitive".to_owned(), TypeId::CASE_INSENSITIVE),
]);
- let mut info = crate::LocalInformation::default();
+ let mut info = LocalInformation::default();
- // Add undefined
+ // Add undefined as a variable
let variables = {
let variable_or_import = VariableOrImport::Variable {
mutability: crate::features::variables::VariableMutability::Constant,
declared_at: source_map::Nullable::NULL,
context: None,
+ allow_reregistration: false,
};
let undefined_id = variable_or_import.get_id();
let variables = [("undefined".to_owned(), variable_or_import)];
diff --git a/checker/src/diagnostics.rs b/checker/src/diagnostics.rs
index 9b7fe104..d2c68fad 100644
--- a/checker/src/diagnostics.rs
+++ b/checker/src/diagnostics.rs
@@ -1,13 +1,15 @@
//! Contains type checking errors, warnings and related structures
-
-#![allow(clippy::upper_case_acronyms)]
-
use crate::{
- context::{environment::Label, information::InformationChain},
- diagnostics, get_closest,
+ context::{environment::Label, AssignmentError, InformationChain},
+ diagnostics,
+ features::{
+ modules::CouldNotOpenFile, operations::MathematicalAndBitwise, CannotDeleteFromError,
+ },
types::{
- calling::FunctionCallingError, printing::print_type_with_type_arguments, GenericChain,
- GenericChainLink,
+ calling::FunctionCallingError,
+ printing::print_type_with_type_arguments,
+ properties::{assignment::SetPropertyError, PropertyKey},
+ GenericChain, GenericChainLink,
},
};
use source_map::{SourceId, SpanWithSource};
@@ -50,6 +52,7 @@ pub enum Diagnostic {
}
/// Temporary dead zone. Between the variable identifier being hoisted and the value being assigned
+#[allow(clippy::upper_case_acronyms)]
pub struct TDZ {
pub variable_name: String,
pub position: SpanWithSource,
@@ -153,6 +156,10 @@ impl DiagnosticsContainer {
Ok(self)
}
}
+
+ pub fn count(&self) -> usize {
+ self.diagnostics.len()
+ }
}
impl IntoIterator for DiagnosticsContainer {
@@ -168,15 +175,28 @@ impl IntoIterator for DiagnosticsContainer {
use crate::types::{printing::print_type, TypeId, TypeStore};
/// TODO could be more things, for instance a property missing etc
-pub enum TypeStringRepresentation {
- Type(String),
-}
+pub struct TypeStringRepresentation(String);
-pub enum PropertyRepresentation {
+pub enum PropertyKeyRepresentation {
Type(String),
StringKey(String),
}
+impl PropertyKeyRepresentation {
+ pub fn new(
+ under: &PropertyKey,
+ environment: &impl InformationChain,
+ types: &TypeStore,
+ ) -> PropertyKeyRepresentation {
+ match under.clone() {
+ PropertyKey::String(s) => PropertyKeyRepresentation::StringKey(s.to_string()),
+ PropertyKey::Type(t) => {
+ PropertyKeyRepresentation::Type(print_type(t, types, environment, false))
+ }
+ }
+ }
+}
+
impl TypeStringRepresentation {
#[must_use]
pub fn from_type_id(
@@ -186,7 +206,7 @@ impl TypeStringRepresentation {
debug_mode: bool,
) -> Self {
let value = print_type(id, types, ctx, debug_mode);
- Self::Type(value)
+ Self(value)
}
#[must_use]
@@ -198,68 +218,66 @@ impl TypeStringRepresentation {
debug_mode: bool,
) -> Self {
let value = print_type_with_type_arguments(id, type_arguments, types, ctx, debug_mode);
- Self::Type(value)
+ Self(value)
}
/// TODO working it out
pub(crate) fn from_property_constraint(
- property_constraint: crate::context::Logical,
+ property_constraint: crate::types::logical::Logical,
generics: GenericChain,
ctx: &impl InformationChain,
types: &TypeStore,
debug_mode: bool,
) -> TypeStringRepresentation {
match property_constraint {
- crate::context::Logical::Pure(constraint) => match constraint {
+ crate::types::logical::Logical::Pure(constraint) => match constraint.inner_simple() {
crate::PropertyValue::Value(v) => {
- let value = print_type_with_type_arguments(v, generics, types, ctx, debug_mode);
- Self::Type(value)
+ let value =
+ print_type_with_type_arguments(*v, generics, types, ctx, debug_mode);
+ Self(value)
}
+ crate::PropertyValue::GetterAndSetter { .. } => todo!(),
crate::PropertyValue::Getter(_) => todo!(),
crate::PropertyValue::Setter(_) => todo!(),
- crate::PropertyValue::Deleted => todo!(),
- crate::PropertyValue::ConditionallyExists { .. } => todo!(),
+ crate::PropertyValue::Deleted => Self("never".to_owned()),
+ crate::PropertyValue::ConditionallyExists { .. }
+ | crate::PropertyValue::Configured { .. } => unreachable!(),
},
- crate::context::Logical::Or { .. } => {
- todo!()
- // let left = Self::from_property_constraint(*left, None, ctx, types, debug_mode);
- // let right = Self::from_property_constraint(*right, None, ctx, types, debug_mode);
+ crate::types::logical::Logical::Or { condition, left, right } => {
+ let left_right = (*left, *right);
+ // if let (Ok(left), Ok(right)) = left_right {
+ // let mut left =
+ // Self::from_property_constraint(left, None, ctx, types, debug_mode);
+ // let right = Self::from_property_constraint(right, None, ctx, types, debug_mode);
- // #[allow(irrefutable_let_patterns)]
- // if let (TypeStringRepresentation::Type(mut l), TypeStringRepresentation::Type(r)) =
- // (left, right)
- // {
- // l.push_str(&r);
- // TypeStringRepresentation::Type(l)
+ // crate::utilities::notify!("Here?");
+ // left.0.push_str(" | ");
+ // left.0.push_str(&right.0);
+ // Self(left.0)
// } else {
- // unreachable!()
+ crate::utilities::notify!("Printing {:?} base on {:?}", left_right, condition);
+ Self("TODO".to_owned())
// }
}
- crate::context::Logical::Implies { on, antecedent } => {
+ crate::types::logical::Logical::Implies { on, antecedent } => {
if generics.is_some() {
todo!("chaining")
}
- Self::from_property_constraint(
- *on,
- Some(GenericChainLink::Link {
- parent_link: None,
- value: &antecedent,
- from: TypeId::UNIMPLEMENTED_ERROR_TYPE,
- }),
- ctx,
- types,
- debug_mode,
- )
+ let generics = Some(GenericChainLink::PartiallyAppliedGenericArgumentsLink {
+ parent_link: None,
+ value: &antecedent,
+ from: TypeId::UNIMPLEMENTED_ERROR_TYPE,
+ });
+ Self::from_property_constraint(*on, generics, ctx, types, debug_mode)
}
+ crate::types::logical::Logical::BasedOnKey { .. } => todo!(),
}
}
}
impl Display for TypeStringRepresentation {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- match self {
- TypeStringRepresentation::Type(ty) => f.write_str(ty),
- }
+ f.write_str(&self.0)
}
}
@@ -271,25 +289,30 @@ impl From for Diagnostic {
}
}
-use crate::{
- context::AssignmentError,
- features::{modules::CouldNotOpenFile, operations::MathematicalAndBitwise},
-};
-
/// Reasons for errors, intermediate type for generating [Diagnostic]s
/// e.g. cannot Call, cannot equate, duplicate key etc
-#[allow(unused)]
pub(crate) enum TypeCheckError<'a> {
FunctionCallingError(FunctionCallingError),
JSXCallingError(FunctionCallingError),
- TemplateLiteralError(FunctionCallingError),
+ TemplateLiteralCallingError(FunctionCallingError),
+ GetterCallingError(FunctionCallingError),
+ SetterCallingError(FunctionCallingError),
+ /// From calling super
+ SuperCallError(FunctionCallingError),
+ /// When accessing
PropertyDoesNotExist {
on: TypeStringRepresentation,
- property: PropertyRepresentation,
- site: SpanWithSource,
+ property: PropertyKeyRepresentation,
+ position: SpanWithSource,
possibles: Vec<&'a str>,
},
+ /// When accessing
+ CyclicTypeAlias {
+ position: SpanWithSource,
+ },
+ #[allow(dead_code)]
NotInLoopOrCouldNotFindLabel(NotInLoopOrCouldNotFindLabel),
+ #[allow(dead_code)]
RestParameterAnnotationShouldBeArrayType(SpanWithSource),
CouldNotFindVariable {
variable: &'a str,
@@ -298,10 +321,15 @@ pub(crate) enum TypeCheckError<'a> {
},
CouldNotFindType(&'a str, Vec<&'a str>, SpanWithSource),
TypeHasNoGenericParameters(String, SpanWithSource),
+ /// For all `=`, including from declarations
AssignmentError(AssignmentError),
+ #[allow(dead_code)]
InvalidComparison(TypeStringRepresentation, TypeStringRepresentation),
+ #[allow(dead_code)]
InvalidAddition(TypeStringRepresentation, TypeStringRepresentation),
+ #[allow(dead_code)]
InvalidUnaryOperation(crate::features::operations::PureUnary, TypeStringRepresentation),
+ SetPropertyError(SetPropertyError),
ReturnedTypeDoesNotMatch {
expected_return_type: TypeStringRepresentation,
returned_type: TypeStringRepresentation,
@@ -309,76 +337,57 @@ pub(crate) enum TypeCheckError<'a> {
annotation_position: SpanWithSource,
returned_position: SpanWithSource,
},
- // TODO are these the same errors?
- TypeIsNotIndexable(TypeStringRepresentation),
- TypeIsNotIterable(TypeStringRepresentation),
- // This could be a syntax error but that is difficult to type...
+ /// This could be a syntax error but that is difficult to type...
NonTopLevelExport(SpanWithSource),
FieldNotExported {
file: &'a str,
importing: &'a str,
position: SpanWithSource,
+ possibles: Vec<&'a str>,
},
- InvalidJSXAttribute {
- attribute_name: String,
- attribute_type: TypeStringRepresentation,
- value_type: TypeStringRepresentation,
- // TODO
- attribute_type_site: (),
- value_site: SpanWithSource,
- },
- InvalidJSXInterpolatedValue {
- interpolation_site: SpanWithSource,
- expected: TypeStringRepresentation,
- found: TypeStringRepresentation,
- },
- /// for the `satisfies` keyword
+ /// For the `satisfies` keyword
NotSatisfied {
at: SpanWithSource,
expected: TypeStringRepresentation,
found: TypeStringRepresentation,
},
- // catch type is not compatible with thrown type
+ /// Catch type is not compatible with thrown type
CatchTypeDoesNotMatch {
at: SpanWithSource,
expected: TypeStringRepresentation,
found: TypeStringRepresentation,
},
+ /// Something the checker does not supported
Unsupported {
thing: &'static str,
at: SpanWithSource,
},
- ReDeclaredVariable {
- name: &'a str,
- position: SpanWithSource,
- },
InvalidDefaultParameter {
at: SpanWithSource,
expected: TypeStringRepresentation,
found: TypeStringRepresentation,
},
/// TODO temp, needs more info
+ #[allow(dead_code)]
FunctionDoesNotMeetConstraint {
function_constraint: TypeStringRepresentation,
function_type: TypeStringRepresentation,
position: SpanWithSource,
},
- StatementsNotRun {
- between: SpanWithSource,
- },
CannotRedeclareVariable {
name: String,
position: SpanWithSource,
},
- // TODO parameter position
+ /// This is for structure generics
+ #[allow(dead_code)]
GenericArgumentDoesNotMeetRestriction {
parameter_restriction: TypeStringRepresentation,
argument: TypeStringRepresentation,
position: SpanWithSource,
},
- NotDefinedOperator(&'static str, SpanWithSource),
- PropertyNotWriteable(SpanWithSource),
+ #[allow(dead_code)]
NotTopLevelImport(SpanWithSource),
+ #[allow(dead_code)]
DoubleDefaultExport(SpanWithSource),
CannotOpenFile {
file: CouldNotOpenFile,
@@ -386,6 +395,8 @@ pub(crate) enum TypeCheckError<'a> {
possibles: Vec<&'a str>,
partial_import_path: &'a str,
},
+ /// WIP
+ #[allow(dead_code)]
VariableNotDefinedInContext {
variable: &'a str,
expected_context: &'a str,
@@ -393,18 +404,20 @@ pub(crate) enum TypeCheckError<'a> {
position: SpanWithSource,
},
TypeNeedsTypeArguments(&'a str, SpanWithSource),
- CannotFindType(&'a str, Vec<&'a str>, SpanWithSource),
TypeAlreadyDeclared {
name: String,
position: SpanWithSource,
},
+ #[allow(clippy::upper_case_acronyms)]
TDZ(TDZ),
+ #[allow(dead_code)]
InvalidMathematicalOrBitwiseOperation {
operator: MathematicalAndBitwise,
lhs: TypeStringRepresentation,
rhs: TypeStringRepresentation,
position: SpanWithSource,
},
+ #[allow(dead_code)]
InvalidCast {
position: SpanWithSource,
from: TypeStringRepresentation,
@@ -412,6 +425,7 @@ pub(crate) enum TypeCheckError<'a> {
},
/// TODO Position = Function body position. Could it be better
/// TODO maybe warning?
+ #[allow(dead_code)]
UnreachableVariableClosedOver(String, SpanWithSource),
IncompatibleOverloadParameter {
parameter_position: SpanWithSource,
@@ -425,52 +439,33 @@ pub(crate) enum TypeCheckError<'a> {
base: TypeStringRepresentation,
overload: TypeStringRepresentation,
},
+ FunctionWithoutBodyNotAllowedHere {
+ position: SpanWithSource,
+ },
+ CannotDeleteProperty(CannotDeleteFromError),
}
#[allow(clippy::useless_format)]
-pub fn get_possibles_message(possibles: Vec<&str>, reference: &str) -> String {
- let mut binding = get_closest(possibles.into_iter(), reference).unwrap_or(vec![]);
- let candidates: &mut [&str] = binding.as_mut_slice();
- candidates.sort_unstable();
- match candidates {
+pub fn get_possibles_message(possibles: &[&str]) -> String {
+ match possibles {
[] => format!(""),
- [a] => format!("Did you mean {a}?"),
- [a, b] => format!("Did you mean {a} or {b}?"),
- [a, b, c] => format!("Did you mean {a}, {b} or {c}?"),
- [a @ .., b] => format!("Did you mean {items} or {b}?", items = a.join(", ")),
+ [a] => format!("Did you mean '{a}'?"),
+ [a @ .., b] => {
+ let mut iter = a.iter();
+ let first = format!("'{first}'", first = iter.next().unwrap());
+ format!(
+ "Did you mean {items} or '{b}'?",
+ items = iter.fold(first, |acc, item| format!("{acc}, '{item}'"))
+ )
+ }
}
}
-pub fn get_possibles_message_for_imports(possibles: &[&str], reference: &str) -> String {
- let candidates = possibles
- .iter()
- .filter(|file| !file.ends_with(".d.ts"))
- .filter_map(|file| file.strip_suffix(".ts"))
- .map(|file| {
- if file.starts_with("./") || file.starts_with("../") {
- file.to_string()
- } else {
- "./".to_string() + file
- }
- })
- .collect::>();
-
- get_possibles_message(candidates.iter().map(AsRef::as_ref).collect::>(), reference)
-}
-
-pub fn get_property_does_not_exist_message(
- property: PropertyRepresentation,
- on: &TypeStringRepresentation,
- possibles: Vec<&str>,
-) -> String {
- match property {
- PropertyRepresentation::Type(ty) => {
- format!("No property of type {ty} on {on}. {}", get_possibles_message(possibles, &ty))
- }
- PropertyRepresentation::StringKey(property) => format!(
- "No property '{property}' on {on}. {}",
- get_possibles_message(possibles, &property)
- ),
+fn map_error_empty(n: Vec, cb: impl FnOnce(Vec) -> T) -> T {
+ if n.is_empty() {
+ ::default()
+ } else {
+ cb(n)
}
}
@@ -478,314 +473,367 @@ impl From> for Diagnostic {
fn from(error: TypeCheckError<'_>) -> Self {
let kind = super::DiagnosticKind::Error;
match error {
- TypeCheckError::CouldNotFindVariable { variable, possibles, position } => {
- Diagnostic::Position {
- reason: format!(
- "Could not find variable '{variable}' in scope. {}", get_possibles_message(possibles, variable)),
+ TypeCheckError::CouldNotFindVariable { variable, possibles, position } => {
+ Diagnostic::PositionWithAdditionalLabels {
+ reason: format!("Could not find variable '{variable}' in scope"),
+ labels: map_error_empty(possibles, |possibles| vec![(
+ get_possibles_message(&possibles),
position,
- kind,
- }
- }
- TypeCheckError::CouldNotFindType(reference, possibles, pos) => Diagnostic::Position {
- reason: format!("Could not find type '{reference}'. {}", get_possibles_message(possibles, reference)),
- position: pos,
+ )]),
+ position,
kind,
- },
- TypeCheckError::PropertyDoesNotExist { property, on, site, possibles } => {
- Diagnostic::Position {
- reason: get_property_does_not_exist_message(property, &on, possibles),
- position: site,
- kind,
- }
}
- TypeCheckError::FunctionCallingError(error) => function_calling_error_diagnostic(error, kind, ""),
- TypeCheckError::JSXCallingError(error) => function_calling_error_diagnostic(error, kind, " (in JSX)"),
- TypeCheckError::TemplateLiteralError(error) => function_calling_error_diagnostic(error, kind, " (in template literal)"),
- TypeCheckError::AssignmentError(error) => match error {
- AssignmentError::DoesNotMeetConstraint {
- variable_type,
- variable_site,
- value_type,
- value_site,
- } => Diagnostic::PositionWithAdditionalLabels {
- reason: format!(
- "Type {value_type} is not assignable to type {variable_type}",
- ),
- position: value_site,
- labels: vec![(
- format!("Variable declared with type {variable_type}"),
- variable_site,
- )],
- kind,
- },
- AssignmentError::PropertyConstraint {
- property_constraint: property_type,
- value_type,
- assignment_position,
- } => Diagnostic::Position {
- reason: format!(
- "Type {value_type} does not meet property constraint {property_type}"
- ),
- position: assignment_position,
- kind,
+ }
+ TypeCheckError::CouldNotFindType(reference, possibles, position) => Diagnostic::PositionWithAdditionalLabels {
+ reason: format!("Could not find type '{reference}'"),
+ position,
+ labels: map_error_empty(possibles, |possibles| vec![(
+ get_possibles_message(&possibles),
+ position,
+ )]),
+ kind,
+ },
+ TypeCheckError::PropertyDoesNotExist { property, on, position, possibles } => {
+ Diagnostic::PositionWithAdditionalLabels {
+ reason: match property {
+ PropertyKeyRepresentation::Type(ty) => format!("No property of type {ty} on {on}"),
+ PropertyKeyRepresentation::StringKey(property) => format!("No property '{property}' on {on}"),
},
- AssignmentError::Constant(position) => Diagnostic::Position {
- reason: "Cannot assign to constant".into(),
+ position,
+ labels: map_error_empty(possibles, |possibles| vec![(
+ get_possibles_message(&possibles),
position,
- kind,
- },
- AssignmentError::VariableNotFound { variable, assignment_position } => {
- Diagnostic::Position {
- reason: format!("Cannot assign to unknown variable '{variable}'"),
- position: assignment_position,
- kind,
- }
- }
- AssignmentError::TDZ(TDZ { variable_name, position }) => {
- Diagnostic::Position {
- reason: format!("Cannot assign to '{variable_name}' before declaration"),
- position,
- kind,
- }
- }
- },
- TypeCheckError::InvalidJSXAttribute {
- attribute_name,
- attribute_type,
- value_type,
- attribute_type_site: _variable_site,
- value_site,
- } => Diagnostic::Position {
- reason: format!(
- "Type {attribute_name} is not assignable to {value_type} attribute of type {attribute_type}",
- ),
- position: value_site,
+ )]),
kind,
- },
- TypeCheckError::ReturnedTypeDoesNotMatch {
- annotation_position,
- returned_position,
- expected_return_type,
- returned_type,
+ }
+ }
+ TypeCheckError::FunctionCallingError(error) => function_calling_error_diagnostic(error, kind, ""),
+ TypeCheckError::JSXCallingError(error) => function_calling_error_diagnostic(error, kind, " (in JSX)"),
+ TypeCheckError::GetterCallingError(error) => function_calling_error_diagnostic(error, kind, " (in getter)"),
+ TypeCheckError::SetterCallingError(error) => function_calling_error_diagnostic(error, kind, " (in setter)"),
+ TypeCheckError::TemplateLiteralCallingError(error) => {
+ function_calling_error_diagnostic(error, kind, " (in template literal)")
+ },
+ TypeCheckError::SuperCallError(error) => function_calling_error_diagnostic(error, kind, " (in super call)"),
+ TypeCheckError::AssignmentError(error) => match error {
+ AssignmentError::DoesNotMeetConstraint {
+ variable_type,
+ variable_position,
+ value_type,
+ value_position,
} => Diagnostic::PositionWithAdditionalLabels {
reason: format!(
- "Cannot return {returned_type} because the function is expected to return {expected_return_type}",
+ "Type {value_type} is not assignable to type {variable_type}",
),
+ position: value_position,
labels: vec![(
- format!("Function annotated to return {expected_return_type} here"),
- annotation_position,
+ format!("Variable declared with type {variable_type}"),
+ variable_position,
)],
- position: returned_position,
kind,
},
- TypeCheckError::InvalidDefaultParameter {
- expected,
- found,
- at,
- } => Diagnostic::Position {
- reason: format!(
- "Cannot use a default value of type {found} for parameter of type {expected}",
- ),
- position: at,
- kind,
- },
- TypeCheckError::CatchTypeDoesNotMatch {
- expected,
- found,
- at,
+ AssignmentError::PropertyConstraint {
+ property_constraint: property_type,
+ value_type,
+ assignment_position,
} => Diagnostic::Position {
reason: format!(
- "Cannot catch type {found} because the try block throws {expected}",
+ "Type {value_type} does not meet property constraint {property_type}"
),
- position: at,
+ position: assignment_position,
kind,
},
- TypeCheckError::TypeHasNoGenericParameters(name, position) => {
- Diagnostic::Position {
- reason: format!("Type '{name}' has no generic parameters",),
- position,
- kind,
- }
- }
- TypeCheckError::InvalidComparison(_, _) => todo!(),
- TypeCheckError::InvalidAddition(_, _) => todo!(),
- TypeCheckError::InvalidUnaryOperation(_, _) => todo!(),
- TypeCheckError::TypeIsNotIndexable(_) => todo!(),
- TypeCheckError::TypeIsNotIterable(_) => todo!(),
- TypeCheckError::NonTopLevelExport(position) => Diagnostic::Position {
- reason: "Cannot export at not top level".to_owned(),
+ AssignmentError::Constant(position) => Diagnostic::Position {
+ reason: "Cannot assign to constant".into(),
position,
kind,
},
- TypeCheckError::FieldNotExported { file, importing, position } => {
- Diagnostic::Position {
- reason: format!("{importing} not exported from {file}"),
- position,
- kind,
- }
- }
- TypeCheckError::InvalidJSXInterpolatedValue {
- interpolation_site: _,
- expected: _,
- found: _,
- } => todo!(),
- TypeCheckError::RestParameterAnnotationShouldBeArrayType(pos) => {
+ AssignmentError::VariableNotFound { variable, assignment_position } => {
Diagnostic::Position {
- reason: "Rest parameter annotation should be array type".to_owned(),
- position: pos,
+ reason: format!("Cannot assign to unknown variable '{variable}'"),
+ position: assignment_position,
kind,
}
}
- TypeCheckError::Unsupported { thing, at } => Diagnostic::Position {
- reason: format!("Unsupported: {thing}"),
- position: at,
- kind,
- },
- TypeCheckError::ReDeclaredVariable { name, position } => {
+ AssignmentError::TDZ(TDZ { variable_name, position }) => {
Diagnostic::Position {
- reason: format!("Cannot declare variable {name}"),
+ reason: format!("Cannot assign to '{variable_name}' before declaration"),
position,
kind,
}
}
- TypeCheckError::FunctionDoesNotMeetConstraint {
- function_constraint,
- function_type,
+ },
+ TypeCheckError::ReturnedTypeDoesNotMatch {
+ annotation_position,
+ returned_position,
+ expected_return_type,
+ returned_type,
+ } => Diagnostic::PositionWithAdditionalLabels {
+ reason: format!(
+ "Cannot return {returned_type} because the function is expected to return {expected_return_type}"
+ ),
+ labels: vec![(
+ format!("Function annotated to return {expected_return_type} here"),
+ annotation_position,
+ )],
+ position: returned_position,
+ kind,
+ },
+ TypeCheckError::InvalidDefaultParameter {
+ expected,
+ found,
+ at,
+ } => Diagnostic::Position {
+ reason: format!( "Cannot use a default value of type {found} for parameter of type {expected}"),
+ position: at,
+ kind,
+ },
+ TypeCheckError::CatchTypeDoesNotMatch {
+ expected,
+ found,
+ at,
+ } => Diagnostic::Position {
+ reason: format!( "Cannot catch type {found} because the try block throws {expected}" ),
+ position: at,
+ kind,
+ },
+ TypeCheckError::TypeHasNoGenericParameters(name, position) => {
+ Diagnostic::Position {
+ reason: format!("Type '{name}' has no generic parameters"),
position,
- } => Diagnostic::Position {
- reason: format!(
- "{function_constraint} constraint on function does not match synthesised form {function_type}",
- ),
+ kind,
+ }
+ }
+ TypeCheckError::InvalidComparison(_, _) => todo!(),
+ TypeCheckError::InvalidAddition(_, _) => todo!(),
+ TypeCheckError::InvalidUnaryOperation(_, _) => todo!(),
+ TypeCheckError::NonTopLevelExport(position) => Diagnostic::Position {
+ reason: "Cannot export at not top level".to_owned(),
+ position,
+ kind,
+ },
+ TypeCheckError::FieldNotExported { file, importing, position, possibles } => {
+ Diagnostic::PositionWithAdditionalLabels {
+ reason: format!("{importing} not exported from {file}"),
position,
kind,
- },
- TypeCheckError::StatementsNotRun { between } => Diagnostic::Position {
- reason: "Statements are never run".to_owned(),
- position: between,
+ labels: map_error_empty(possibles, |possibles| vec![(
+ get_possibles_message(&possibles),
+ position,
+ )]),
+ }
+ }
+ TypeCheckError::RestParameterAnnotationShouldBeArrayType(pos) => {
+ Diagnostic::Position {
+ reason: "Rest parameter annotation should be array type".to_owned(),
+ position: pos,
kind,
- },
- TypeCheckError::NotSatisfied { at, expected, found } => Diagnostic::Position {
- reason: format!("Expected {expected}, found {found}"),
- position: at,
+ }
+ }
+ TypeCheckError::Unsupported { thing, at } => Diagnostic::Position {
+ reason: format!("Unsupported: {thing}"),
+ position: at,
+ kind,
+ },
+ TypeCheckError::FunctionDoesNotMeetConstraint {
+ function_constraint,
+ function_type,
+ position,
+ } => Diagnostic::Position {
+ reason: format!(
+ "{function_constraint} constraint on function does not match synthesised form {function_type}",
+ ),
+ position,
+ kind,
+ },
+ TypeCheckError::NotSatisfied { at, expected, found } => Diagnostic::Position {
+ reason: format!("Expected {expected}, found {found}"),
+ position: at,
+ kind,
+ },
+ TypeCheckError::CannotRedeclareVariable { name, position } => {
+ Diagnostic::Position {
+ reason: format!("Cannot redeclare variable '{name}'"),
+ position,
kind,
- },
- TypeCheckError::CannotRedeclareVariable { name, position } => {
- Diagnostic::Position {
- reason: format!("Cannot redeclare variable '{name}'"),
- position,
- kind,
- }
}
- TypeCheckError::NotDefinedOperator(op, position) => Diagnostic::Position {
- reason: format!("Operator not typed {op}"),
+ }
+ TypeCheckError::GenericArgumentDoesNotMeetRestriction {
+ argument,
+ parameter_restriction,
+ position,
+ } => Diagnostic::Position {
+ reason: format!(
+ "Generic argument {argument} does not match {parameter_restriction}"
+ ),
+ position,
+ kind,
+ },
+ TypeCheckError::NotTopLevelImport(position) => Diagnostic::Position {
+ reason: "Import must be in the top of the scope".to_owned(),
+ position,
+ kind,
+ },
+ TypeCheckError::DoubleDefaultExport(_) => todo!(),
+ TypeCheckError::CannotOpenFile { file, import_position, possibles, partial_import_path } => if let Some(import_position) = import_position {
+ Diagnostic::PositionWithAdditionalLabels {
+ reason: format!("Cannot find {partial_import_path}"),
+ position: import_position,
+ kind,
+ labels: map_error_empty(possibles, |possibles| vec![(
+ get_possibles_message(&possibles),
+ import_position,
+ )])
+ }
+ } else {
+ Diagnostic::Global { reason: format!("Cannot find file {}", file.0.display()), kind }
+ },
+ TypeCheckError::VariableNotDefinedInContext {
+ variable,
+ expected_context,
+ current_context,
+ position,
+ } => Diagnostic::Position {
+ reason: format!("'{variable}' is only available on the {expected_context}, currently in {current_context}"),
+ position,
+ kind,
+ },
+ TypeCheckError::TypeNeedsTypeArguments(ty, position) => Diagnostic::Position {
+ reason: format!("Type {ty} requires type arguments"),
+ position,
+ kind,
+ },
+ TypeCheckError::TypeAlreadyDeclared { name, position } => Diagnostic::Position {
+ reason: format!("Type named '{name}' already declared"),
+ position,
+ kind,
+ },
+ TypeCheckError::TDZ(TDZ { position, variable_name }) => Diagnostic::Position {
+ reason: format!("Variable '{variable_name}' used before declaration"),
+ position,
+ kind,
+ },
+ TypeCheckError::InvalidMathematicalOrBitwiseOperation { operator, lhs, rhs, position } => Diagnostic::Position {
+ // TODO temp
+ reason: format!("Cannot {lhs} {operator:?} {rhs}"),
+ position,
+ kind,
+ },
+ TypeCheckError::NotInLoopOrCouldNotFindLabel(_) => todo!(),
+ TypeCheckError::InvalidCast { position, from, to } => {
+ Diagnostic::Position {
+ reason: format!("Cannot cast {from} to {to}"),
position,
kind,
- },
- TypeCheckError::PropertyNotWriteable(position) => Diagnostic::Position {
- reason: "Property not writeable".into(),
+ }
+ },
+ TypeCheckError::UnreachableVariableClosedOver(name, function_position) => {
+ Diagnostic::Position {
+ reason: format!("Function contains unreachable closed over variable '{name}'"),
+ position: function_position,
+ kind,
+ }
+ },
+ TypeCheckError::IncompatibleOverloadParameter { parameter_position, overloaded_parameter_position, parameter, overloaded_parameter } => Diagnostic::PositionWithAdditionalLabels {
+ reason: format!(
+ "Overload with parameter of {overloaded_parameter} does not meet base parameter {parameter}"
+ ),
+ labels: vec![(
+ format!("Function has base type {parameter} here"),
+ parameter_position,
+ )],
+ position: overloaded_parameter_position,
+ kind,
+ },
+ TypeCheckError::IncompatibleOverloadReturnType { base_position, overload_position, base, overload } => Diagnostic::PositionWithAdditionalLabels {
+ reason: format!(
+ "Cannot return {overload} in overload because base function is expected to return {base}"
+ ),
+ labels: vec![(
+ format!("Function annotated to return {base} here"),
+ base_position,
+ )],
+ position: overload_position,
+ kind,
+ },
+ TypeCheckError::FunctionWithoutBodyNotAllowedHere { position } => {
+ Diagnostic::Position {
+ reason: "Function without body not allowed here".to_owned(),
position,
kind,
- },
- TypeCheckError::GenericArgumentDoesNotMeetRestriction {
- argument,
- parameter_restriction,
+ }
+ }
+ TypeCheckError::CyclicTypeAlias { position } => {
+ Diagnostic::Position {
+ reason: "Circular type reference".to_owned(),
position,
- } => Diagnostic::Position {
- reason: format!(
- "Generic argument {argument} does not match {parameter_restriction}"
- ),
+ kind,
+ }
+ }
+ TypeCheckError::CannotDeleteProperty(CannotDeleteFromError::Constraint { constraint, position }) => {
+ Diagnostic::Position {
+ reason: format!("Cannot delete from object constrained to {constraint}"),
position,
kind,
- },
- TypeCheckError::NotTopLevelImport(position) => Diagnostic::Position {
- reason: "Import must be in the top of the scope".to_owned(),
+ }
+ }
+ TypeCheckError::CannotDeleteProperty(CannotDeleteFromError::NonConfigurable {
+ position,
+ }) => {
+ Diagnostic::Position {
+ reason: "Cannot delete from non-configurable property".to_owned(),
position,
kind,
- },
- TypeCheckError::DoubleDefaultExport(_) => todo!(),
- TypeCheckError::CannotOpenFile { file, import_position, possibles, partial_import_path } => if let Some(import_position) = import_position {
- Diagnostic::Position {
- reason: format!("Cannot find {partial_import_path}. {}", get_possibles_message_for_imports(possibles.as_slice(), partial_import_path)),
- position: import_position,
- kind,
- }
- } else {
- Diagnostic::Global { reason: format!("Cannot find file {}", file.0.display()), kind }
- },
- TypeCheckError::VariableNotDefinedInContext {
- variable,
- expected_context,
- current_context,
+ }
+ }
+ TypeCheckError::SetPropertyError(error) => match error {
+ SetPropertyError::NotWriteable {
+ property,
position,
} => Diagnostic::Position {
- reason: format!("'{variable}' is only available on the {expected_context}, currently in {current_context}"),
+ reason: match property {
+ PropertyKeyRepresentation::Type(ty) => format!("Cannot write to property of type {ty}"),
+ PropertyKeyRepresentation::StringKey(property) => format!("Cannot write to property '{property}'")
+ },
position,
kind,
},
- TypeCheckError::TypeNeedsTypeArguments(ty, position) => Diagnostic::Position {
- reason: format!("Type {ty} requires type arguments"),
+ SetPropertyError::DoesNotMeetConstraint {
+ property_constraint,
+ value_type,
+ reason: _,
position,
- kind,
- },
- TypeCheckError::CannotFindType(ty, possibles, position) => Diagnostic::Position {
- reason: format!("Cannot find type {ty}. {}",get_possibles_message(possibles,ty)),
+ } => Diagnostic::Position {
+ reason: format!(
+ "Type {value_type} does not meet property constraint {property_constraint}"
+ ),
position,
kind,
},
- TypeCheckError::TypeAlreadyDeclared { name, position } => Diagnostic::Position {
- reason: format!("Type named '{name}' already declared"),
+ SetPropertyError::AssigningToGetter {
+ property,
position,
- kind,
- },
- TypeCheckError::TDZ(TDZ { position, variable_name }) => Diagnostic::Position {
- reason: format!("Variable '{variable_name}' used before declaration"),
+ } => Diagnostic::Position {
+ reason: match property {
+ PropertyKeyRepresentation::Type(ty) => format!("Cannot write to property of type {ty} as it is a getter"),
+ PropertyKeyRepresentation::StringKey(property) => format!("Cannot write to property '{property}' as it is a getter")
+ },
position,
kind,
},
- TypeCheckError::InvalidMathematicalOrBitwiseOperation { operator, lhs, rhs, position } => Diagnostic::Position {
- // TODO temp
- reason: format!("Cannot {lhs} {operator:?} {rhs}"),
+ SetPropertyError::AssigningToNonExistent {
+ property,
+ position,
+ } => Diagnostic::Position {
+ reason: match property {
+ PropertyKeyRepresentation::Type(ty) => format!("Cannot write to non-existent property of type {ty}"),
+ PropertyKeyRepresentation::StringKey(property) => format!("Cannot write to non-existent property '{property}'")
+ },
position,
- kind,
- },
- TypeCheckError::NotInLoopOrCouldNotFindLabel(_) => todo!(),
- TypeCheckError::InvalidCast { position, from, to } => {
- Diagnostic::Position {
- reason: format!("Cannot cast {from} to {to}"),
- position,
- kind,
- }
- }
- TypeCheckError::UnreachableVariableClosedOver(name, function_position) => {
- Diagnostic::Position {
- reason: format!("Function contains unreachable closed over variable '{name}'"),
- position: function_position,
- kind,
- }
- }
- TypeCheckError::IncompatibleOverloadParameter { parameter_position, overloaded_parameter_position, parameter, overloaded_parameter } => Diagnostic::PositionWithAdditionalLabels {
- reason: format!(
- "Overload with parameter of {overloaded_parameter} does not meet base parameter {parameter}",
- ),
- labels: vec![(
- format!("Function has base type {parameter} here"),
- parameter_position,
- )],
- position: overloaded_parameter_position,
- kind,
- },
- TypeCheckError::IncompatibleOverloadReturnType { base_position, overload_position, base, overload } => Diagnostic::PositionWithAdditionalLabels {
- reason: format!(
- "Cannot return {overload} in overload because base function is expected to return {base}",
- ),
- labels: vec![(
- format!("Function annotated to return {base} here"),
- base_position,
- )],
- position: overload_position,
kind,
}
}
+ }
}
}
@@ -819,6 +867,12 @@ pub enum TypeCheckWarning {
position: SpanWithSource,
},
InvalidOrUnimplementedDefinitionFileItem(SpanWithSource),
+ /// TODO WIP
+ ConditionalExceptionInvoked {
+ value: TypeStringRepresentation,
+ /// Should be set
+ call_site: SpanWithSource,
+ },
Unreachable(SpanWithSource),
}
@@ -883,10 +937,22 @@ impl From for Diagnostic {
TypeCheckWarning::Unreachable(position) => {
Diagnostic::Position { reason: "Unreachable statement".to_owned(), position, kind }
}
+ TypeCheckWarning::ConditionalExceptionInvoked { value, call_site } => {
+ Diagnostic::Position {
+ reason: format!("Conditional '{value}' was thrown in function"),
+ position: call_site,
+ kind,
+ }
+ }
}
}
}
+/// Only for internal things
+///
+/// WIP
+pub struct InfoDiagnostic(pub String, pub SpanWithSource);
+
#[derive(Debug)]
pub struct CannotFindTypeError<'a>(pub &'a str);
@@ -1011,12 +1077,12 @@ fn function_calling_error_diagnostic(
kind,
},
FunctionCallingError::NoLogicForIdentifier(name, position) => Diagnostic::Position {
- reason: format!("no logic for constant function {name}{context}"),
+ reason: format!("No logic for constant function {name}{context}"),
kind,
position,
},
FunctionCallingError::NeedsToBeCalledWithNewKeyword(position) => Diagnostic::Position {
- reason: "class constructor must be called with new".to_owned(),
+ reason: "Class constructor must be called with new".to_owned(),
kind,
position,
},
@@ -1034,7 +1100,7 @@ fn function_calling_error_diagnostic(
assignment_position,
call_site,
} => Diagnostic::PositionWithAdditionalLabels {
- reason: format!("Invalid assignment to parameter{context}"),
+ reason: format!("Invalid assignment through parameter{context}"),
position: call_site,
kind,
labels: vec![(
@@ -1042,11 +1108,6 @@ fn function_calling_error_diagnostic(
assignment_position,
)],
},
- FunctionCallingError::UnconditionalThrow { value, call_site } => Diagnostic::Position {
- reason: format!("Conditional '{value}' was thrown in function{context}"),
- position: call_site,
- kind,
- },
FunctionCallingError::MismatchedThis { call_site, expected, found } => {
Diagnostic::Position {
reason: format!("The 'this' context of the function is expected to be {expected}, found {found}{context}"),
@@ -1061,5 +1122,25 @@ fn function_calling_error_diagnostic(
kind,
}
}
+ FunctionCallingError::DeleteConstraint { constraint, delete_position, call_site: _ } => {
+ Diagnostic::Position {
+ reason: format!("Cannot delete from object constrained to {constraint}"),
+ position: delete_position,
+ kind,
+ }
+ }
+ FunctionCallingError::NotConfiguarable {
+ property,
+ call_site,
+ } => {
+ Diagnostic::Position {
+ reason: match property {
+ PropertyKeyRepresentation::Type(ty) => format!("Property of type '{ty}' not configurable"),
+ PropertyKeyRepresentation::StringKey(property) => format!("Property '{property}' not configurable"),
+ },
+ position: call_site,
+ kind,
+ }
+ }
}
}
diff --git a/checker/src/events/application.rs b/checker/src/events/application.rs
index 055b8cb3..b21150ef 100644
--- a/checker/src/events/application.rs
+++ b/checker/src/events/application.rs
@@ -3,34 +3,31 @@ use source_map::SpanWithSource;
use super::{CallingTiming, Event, FinalEvent, PrototypeArgument, RootReference};
use crate::{
- context::{
- get_value_of_variable, invocation::InvocationContext, CallCheckingBehavior,
- SetPropertyError,
- },
+ context::{get_value_of_variable, invocation::InvocationContext, CallCheckingBehavior},
diagnostics::{TypeStringRepresentation, TDZ},
events::ApplicationResult,
features::{
- functions::ThisValue,
iteration::{self, IterationKind},
- objects::SpecialObjects,
+ objects::SpecialObject,
+ CannotDeleteFromError,
},
subtyping::type_is_subtype,
types::{
- calling::{self, FunctionCallingError},
- functions::SynthesisedArgument,
+ calling::{self, CallingDiagnostics, FunctionCallingError, SynthesisedArgument, ThisValue},
generics::substitution::SubstitutionArguments,
is_type_truthy_falsy,
printing::print_type,
- properties::{get_property, set_property, PropertyKey, PropertyValue},
+ properties::{assignment::SetPropertyError, get_property, set_property, PropertyValue},
substitute, PartiallyAppliedGenerics, TypeId, TypeStore,
},
Decidable, Environment, Type,
};
-#[derive(Default)]
-pub struct ErrorsAndInfo {
- pub errors: Vec,
- pub warnings: Vec,
+pub(crate) struct ApplicationInput {
+ pub(crate) this_value: ThisValue,
+ pub(crate) call_site: SpanWithSource,
+ /// From above, not log
+ pub(crate) max_inline: u16,
}
/// `type_arguments` are mutable to add new ones during lookup etc
@@ -40,210 +37,194 @@ pub struct ErrorsAndInfo {
#[allow(clippy::too_many_arguments)]
pub(crate) fn apply_events(
events: &[Event],
- this_value: ThisValue,
+ input: &ApplicationInput,
mut type_arguments: &mut SubstitutionArguments,
top_environment: &mut Environment,
target: &mut InvocationContext,
types: &mut TypeStore,
- mut errors: &mut ErrorsAndInfo,
- call_site: SpanWithSource,
+ mut diagnostics: &mut CallingDiagnostics,
) -> Option {
let mut trailing = None::<(TypeId, ApplicationResult)>;
+ // TODO this could be done better
+ let unknown_mode = target.in_unknown();
+
+ // crate::utilities::notify!("Running {:?}", events);
+
let mut idx = 0;
while idx < events.len() {
let event = &events[idx];
- // crate::utilities::notify!("Running single {:?}", event);
+
+ // crate::utilities::notify!("Running single {:?}", event);
+
match &event {
Event::ReadsReference { reference, reflects_dependency, position } => {
+ // if B::CHECK_PARAMETERS {
+ // TODO check free variables from inference
+ // }
+
if let Some(id) = reflects_dependency {
- let value = match reference {
- RootReference::Variable(id) => {
- // Some(&*type_arguments)
- let value =
- get_value_of_variable(top_environment, *id, Some(type_arguments));
- if let Some(ty) = value {
- ty
- } else {
- errors.errors.push(
- crate::types::calling::FunctionCallingError::TDZ {
- error: TDZ {
- variable_name: top_environment
- .get_variable_name(*id)
- .to_owned(),
- position: *position,
- },
- call_site,
- },
+ if unknown_mode {
+ if let RootReference::Variable(variable) = reference {
+ // TODO this is okay for loops, not sure about other cases of this function
+ crate::utilities::notify!(
+ "Setting loop variable here {:?}",
+ reflects_dependency
+ );
+ target
+ .get_latest_info(top_environment)
+ .variable_current_value
+ .insert(*variable, *id);
+ }
+
+ // Think this is correct
+ type_arguments.set_during_application(*id, *id);
+ } else {
+ let value = match reference {
+ RootReference::Variable(id) => {
+ // Some(&*type_arguments)
+ let value = get_value_of_variable(
+ top_environment,
+ *id,
+ Some(type_arguments),
);
- TypeId::ERROR_TYPE
+ if let Some(ty) = value {
+ ty
+ } else {
+ diagnostics.errors.push(
+ crate::types::calling::FunctionCallingError::TDZ {
+ error: TDZ {
+ variable_name: top_environment
+ .get_variable_name(*id)
+ .to_owned(),
+ position: *position,
+ },
+ call_site: input.call_site,
+ },
+ );
+ TypeId::ERROR_TYPE
+ }
}
- }
- RootReference::This => this_value.get(top_environment, types, *position),
- };
- type_arguments.set_during_application(*id, value);
- // crate::utilities::notify!(
- // "Setting free variable argument {:?} here {:?}",
- // *id,
- // type_arguments.arguments
- // );
+ RootReference::This => {
+ input.this_value.get(top_environment, types, *position)
+ }
+ };
+ type_arguments.set_during_application(*id, value);
+ }
}
}
Event::SetsVariable(variable, value, position) => {
- let new_value = substitute(*value, type_arguments, top_environment, types);
+ if unknown_mode {
+ // TODO Top environment?
+ // TODO maybe needs to be returned back up, rather than set here?
+ top_environment.possibly_mutated_variables.insert(*variable);
+ } else {
+ let new_value = substitute(*value, type_arguments, top_environment, types);
- // TODO temp assigns to many contexts, which is bad.
- // Closures should have an indicator of what they close over #56
- let info = target.get_latest_info(top_environment);
- for id in &type_arguments.closures {
- info.closure_current_values
- .insert((*id, RootReference::Variable(*variable)), new_value);
- }
+ // There is probably a way to speed this up. For example `Environment` could have a range?
+ // This also doesn't work around conditionals
+ let in_above_environment =
+ top_environment.variables.values().any(|var| var.get_id() == *variable);
+
+ // TODO temp assigns to many contexts, which is bad.
+ // Closures should have an indicator of what they close over #56
+ let info = target.get_latest_info(top_environment);
+ for id in &type_arguments.closures {
+ info.closure_current_values
+ .insert((*id, RootReference::Variable(*variable)), new_value);
+ }
+
+ if !in_above_environment {
+ info.events.push(Event::SetsVariable(*variable, new_value, *position));
+ }
- info.events.push(Event::SetsVariable(*variable, new_value, *position));
- info.variable_current_value.insert(*variable, new_value);
+ info.variable_current_value.insert(*variable, new_value);
+ }
}
- Event::Getter { on, under, reflects_dependency, publicity, position, bind_this } => {
+ Event::Getter { on, under, reflects_dependency, publicity, position, mode } => {
// let was = on;
let on = substitute(*on, type_arguments, top_environment, types);
// crate::utilities::notify!("was {:?} now {:?}", was, on);
- let under = match under {
- PropertyKey::Type(under) => {
- let ty = substitute(*under, type_arguments, top_environment, types);
- PropertyKey::from_type(ty, types)
- }
- under @ PropertyKey::String(_) => under.clone(),
- };
+ let under = under.substitute(type_arguments, top_environment, types);
let Some((_, value)) = get_property(
on,
*publicity,
&under,
- None,
top_environment,
- target,
+ (target, diagnostics),
types,
*position,
- *bind_this,
+ *mode,
) else {
// TODO getters can fail here
panic!(
- "could not get property {under:?} at {position:?} on {}, (inference or some checking failed)",
- print_type(on, types, top_environment, true)
- );
+ "Could not get property {under:?} at {position:?} on {}, (inference or some checking failed)",
+ print_type(on, types, top_environment, true)
+ );
};
if let Some(id) = reflects_dependency {
type_arguments.set_during_application(*id, value);
+
+ // {
+ // let value = print_type(value, types, top_environment, true);
+ // crate::utilities::notify!("Setting {:?} to {:?}", id, value);
+ // }
}
}
- Event::Setter { on, under, new, initialization, publicity, position } => {
- // let was = on;
+ Event::Setter { on, under, new, publicity, position } => {
let on = substitute(*on, type_arguments, top_environment, types);
- // crate::utilities::notify!("was {:?} now {:?}", was, on);
-
- let under = match under {
- PropertyKey::Type(under) => {
- let ty = substitute(*under, type_arguments, top_environment, types);
- PropertyKey::from_type(ty, types)
- }
- under @ PropertyKey::String(_) => under.clone(),
- };
-
- let new = match new {
- PropertyValue::Value(new) => PropertyValue::Value(substitute(
- *new,
- type_arguments,
- top_environment,
- types,
- )),
- // For declare property
- PropertyValue::Getter(_) => todo!(),
- PropertyValue::Setter(_) => todo!(),
- // TODO this might be a different thing at some point
- PropertyValue::Deleted => {
- top_environment.delete_property(on, &under, *position);
- return None;
- }
- PropertyValue::ConditionallyExists { .. } => {
- todo!()
- }
- };
-
- let _gc = top_environment.as_general_context();
- // crate::utilities::notify!(
- // "[Event::Setter] {}[{}] = {}",
- // crate::types::printing::print_type(on, types, &gc, true),
- // crate::types::printing::print_type(under, types, &gc, true),
- // if let Property::Value(new) = new {
- // crate::types::printing::print_type(new, types, &gc, true)
- // } else {
- // format!("{:#?}", new)
- // }
- // );
+ if unknown_mode {
+ // TODO constraint something?
+ // TODO maybe needs to be returned back up, rather than set here?
+ top_environment.possibly_mutated_objects.insert(on, TypeId::ANY_TYPE);
+ } else {
+ let under = under.substitute(type_arguments, top_environment, types);
+ let new = substitute(*new, type_arguments, top_environment, types);
- if *initialization {
- // TODO temp fix for closures
- let on = if let Type::PartiallyAppliedGenerics(PartiallyAppliedGenerics {
- on,
- arguments: _,
- }) = types.get_type_by_id(on)
{
- *on
- } else {
- on
- };
+ crate::utilities::notify!(
+ "[Event::Setter] ({})[{:?}] = {:?}",
+ crate::types::printing::print_type(on, types, top_environment, true),
+ under,
+ new
+ );
+ }
- target.get_latest_info(top_environment).register_property(
- on,
- *publicity,
- under.clone(),
- new,
- true,
- *position,
- );
- } else {
let result = set_property(
on,
- *publicity,
- &under,
- new.clone(),
+ (*publicity, &under, new),
+ *position,
top_environment,
- target,
+ (target, diagnostics),
types,
- *position,
);
- if let Err(err) = result {
- if let SetPropertyError::DoesNotMeetConstraint {
- property_constraint,
- reason: _,
- } = err
- {
- let value_type = if let PropertyValue::Value(id) = new {
- TypeStringRepresentation::from_type_id(
- id,
- top_environment,
- types,
- false,
- )
+ match result {
+ Ok(()) => {}
+ Err(err) => {
+ if let SetPropertyError::DoesNotMeetConstraint {
+ property_constraint,
+ value_type,
+ reason: _,
+ position: _,
+ } = err
+ {
+ diagnostics.errors.push(
+ crate::types::calling::FunctionCallingError::SetPropertyConstraint {
+ property_type: property_constraint,
+ value_type,
+ assignment_position: *position,
+ call_site: input.call_site,
+ },
+ );
} else {
- todo!()
- };
-
- errors.errors.push(
- crate::types::calling::FunctionCallingError::SetPropertyConstraint {
- property_type: property_constraint,
- value_type,
- assignment_position: *position,
- call_site,
- },
- );
- } else {
- unreachable!()
+ unreachable!("set property check failed")
+ }
}
}
}
@@ -255,9 +236,20 @@ pub(crate) fn apply_events(
timing,
called_with_new,
possibly_thrown: _,
- position: _,
+ call_site,
} => {
- let on = substitute(*on, type_arguments, top_environment, types);
+ let on = match on {
+ calling::Callable::Fixed(fixed, this_value) => {
+ crate::utilities::notify!("TODO specialise this?");
+ calling::Callable::Fixed(*fixed, *this_value)
+ }
+ calling::Callable::Type(on) => calling::Callable::Type(substitute(
+ *on,
+ type_arguments,
+ top_environment,
+ types,
+ )),
+ };
// crate::utilities::notify!("was {:?} now {:?}", was, on);
@@ -272,58 +264,47 @@ pub(crate) fn apply_events(
match timing {
CallingTiming::Synchronous => {
- let result = crate::types::calling::call_type(
- on,
- with,
- &crate::types::calling::CallingInput {
- called_with_new: *called_with_new,
- call_site_type_arguments: None,
- // TODO:
- call_site: source_map::Nullable::NULL,
- },
- top_environment,
- target,
- types,
- );
- match result {
- Ok(mut result) => {
- errors.warnings.append(&mut result.warnings);
-
- if let Some(ApplicationResult::Throw { .. }) = result.result {
- // TODO conditional here
- return result.result;
- }
-
- if let Some(reflects_dependency) = reflects_dependency {
- let as_type = calling::application_result_to_return_type(
- result.result,
- top_environment,
- types,
- );
- type_arguments
- .set_during_application(*reflects_dependency, as_type);
- }
+ let input = crate::types::calling::CallingInput {
+ called_with_new: *called_with_new,
+ // TODO:
+ max_inline: input.max_inline,
+ call_site: *call_site,
+ };
+ let result =
+ on.call(with, input, top_environment, (target, diagnostics), types);
+ if let Ok(result) = result {
+ if let Some(ApplicationResult::Throw { .. }) = result.result {
+ // TODO conditional here
+ return result.result;
+ }
- // if result.thrown_type != TypeId::NEVER_TYPE {
- // // TODO
- // // return FinalEvent::Throw {
- // // thrown: result.thrown_type,
- // // position: source_map::Nullable::NULL,
- // // }
- // // .into();
- // }
+ if let Some(reflects_dependency) = reflects_dependency {
+ let as_type = calling::application_result_to_return_type(
+ result.result,
+ top_environment,
+ types,
+ );
+ type_arguments
+ .set_during_application(*reflects_dependency, as_type);
}
- Err(mut other_errors) => {
- crate::utilities::notify!(
- "inference and or checking failed at function"
+
+ // if result.thrown_type != TypeId::NEVER_TYPE {
+ // // TODO
+ // // return FinalEvent::Throw {
+ // // thrown: result.thrown_type,
+ // // position: source_map::Nullable::NULL,
+ // // }
+ // // .into();
+ // }
+ } else {
+ crate::utilities::notify!(
+ "inference and or checking failed at function"
+ );
+ if let Some(reflects_dependency) = reflects_dependency {
+ type_arguments.set_during_application(
+ *reflects_dependency,
+ TypeId::ERROR_TYPE,
);
- errors.errors.append(&mut other_errors.errors);
- if let Some(reflects_dependency) = reflects_dependency {
- type_arguments.set_during_application(
- *reflects_dependency,
- TypeId::ERROR_TYPE,
- );
- }
}
}
}
@@ -359,6 +340,7 @@ pub(crate) fn apply_events(
let (truthy_events, otherwise_events) =
(*truthy_events as usize, *otherwise_events as usize);
let offset = idx + 1;
+
match fixed_result {
Decidable::Known(result) => {
let (start, end) = if result {
@@ -376,13 +358,12 @@ pub(crate) fn apply_events(
target.new_unconditional_target(|target: &mut InvocationContext| {
apply_events(
events_to_run,
- this_value,
+ input,
type_arguments,
top_environment,
target,
types,
- errors,
- *position,
+ diagnostics,
)
});
@@ -403,25 +384,24 @@ pub(crate) fn apply_events(
.evaluate_conditionally(
top_environment,
types,
- condition,
+ (condition, *position),
(truthy_events_slice, otherwise_events_slice),
- (type_arguments, errors),
- |top_environment, types, target, input, data| {
- let (type_arguments, errors) = data;
+ (type_arguments, diagnostics),
+ |top_environment, types, target, events, data| {
+ let (type_arguments, diagnostics) = data;
apply_events(
+ events,
input,
- this_value,
type_arguments,
top_environment,
target,
types,
- errors,
- *position,
+ diagnostics,
)
},
);
- (type_arguments, errors) = data;
+ (type_arguments, diagnostics) = data;
match (truthy_result, otherwise_result) {
(Some(truthy_result), Some(otherwise_result)) => {
@@ -470,46 +450,48 @@ pub(crate) fn apply_events(
// TODO
let is_under_dyn = true;
- let new_object_id =
- match prototype {
- PrototypeArgument::Yeah(prototype) => {
- let prototype =
- substitute(*prototype, type_arguments, top_environment, types);
- target.get_latest_info(top_environment).new_object(
- Some(prototype),
- types,
- *position,
- is_under_dyn,
- )
- }
- PrototypeArgument::None => target
- .get_latest_info(top_environment)
- .new_object(None, types, *position, is_under_dyn),
- PrototypeArgument::Function(id) => types.register_type(
- crate::Type::SpecialObject(SpecialObjects::Function(*id, this_value)),
- ),
- };
+ let new_object_ty = match prototype {
+ PrototypeArgument::Yeah(prototype) => {
+ let prototype =
+ substitute(*prototype, type_arguments, top_environment, types);
+ target.get_latest_info(top_environment).new_object(
+ Some(prototype),
+ types,
+ *position,
+ is_under_dyn,
+ )
+ }
+ PrototypeArgument::None => target.get_latest_info(top_environment).new_object(
+ None,
+ types,
+ *position,
+ is_under_dyn,
+ ),
+ PrototypeArgument::Function(id) => types.register_type(
+ crate::Type::SpecialObject(SpecialObject::Function(*id, input.this_value)),
+ ),
+ };
// TODO conditionally if any properties are structurally generic
- // let new_object_id_with_curried_arguments =
- // curry_arguments(type_arguments, types, new_object_id);
+ // let new_object_ty_with_curried_arguments =
+ // curry_arguments(type_arguments, types, new_object_ty);
// crate::utilities::notify!(
// "Setting {:?} to {:?}",
// referenced_in_scope_as,
- // new_object_id_with_curried_arguments
+ // new_object_ty_with_curried_arguments
// );
if let Some(object_constraint) =
top_environment.get_object_constraint(*referenced_in_scope_as)
{
top_environment.add_object_constraints(
- std::iter::once((new_object_id, object_constraint)),
+ std::iter::once((new_object_ty, object_constraint)),
types,
);
}
- type_arguments.set_during_application(*referenced_in_scope_as, new_object_id);
+ type_arguments.set_during_application(*referenced_in_scope_as, new_object_ty);
}
Event::Iterate { kind, iterate_over, initial } => {
let closure_id = types.new_closure_id();
@@ -554,25 +536,27 @@ pub(crate) fn apply_events(
let offset = idx + 1;
- let () = target.new_loop_iteration(|target| {
+ let result = target.new_loop_iteration(|target| {
let events = &events[offset..(offset + *iterate_over as usize)];
// crate::utilities::notify!("Running in iteration {:?}", events);
iteration::run_iteration_block(
kind,
events,
+ input,
iteration::RunBehavior::Run,
type_arguments,
top_environment,
target,
- errors,
+ diagnostics,
types,
- // TODO iterator.position
- call_site,
- );
+ )
});
- // if result.is_some() {
- // return result;
- // }
+
+ crate::utilities::notify!("Inner loop returned {:?}", result);
+
+ if result.is_some() {
+ return result;
+ }
idx += *iterate_over as usize + 1;
}
Event::ExceptionTrap { investigate, handle, finally, trapped_type_id } => {
@@ -583,13 +567,12 @@ pub(crate) fn apply_events(
let inner_result = apply_events(
&events[offset..(offset + investigate)],
- this_value,
+ input,
type_arguments,
top_environment,
target,
types,
- errors,
- call_site,
+ diagnostics,
);
if let Some(result) = inner_result {
@@ -631,21 +614,23 @@ pub(crate) fn apply_events(
if let crate::subtyping::SubTypeResult::IsNotSubType(_reason) =
result
{
- errors.errors.push(FunctionCallingError::CannotCatch {
- catch: TypeStringRepresentation::from_type_id(
- constraint,
- top_environment,
- types,
- false,
- ),
- thrown: TypeStringRepresentation::from_type_id(
- thrown,
- top_environment,
- types,
- false,
- ),
- thrown_position: position,
- });
+ diagnostics.errors.push(
+ FunctionCallingError::CannotCatch {
+ catch: TypeStringRepresentation::from_type_id(
+ constraint,
+ top_environment,
+ types,
+ false,
+ ),
+ thrown: TypeStringRepresentation::from_type_id(
+ thrown,
+ top_environment,
+ types,
+ false,
+ ),
+ thrown_position: position,
+ },
+ );
}
}
}
@@ -655,13 +640,12 @@ pub(crate) fn apply_events(
let result = apply_events(
handler,
- this_value,
+ input,
type_arguments,
top_environment,
target,
types,
- errors,
- call_site,
+ diagnostics,
);
if result.is_some() {
@@ -677,220 +661,178 @@ pub(crate) fn apply_events(
}
Event::RegisterVariable { .. } => {}
Event::EndOfControlFlow { .. } => {
- crate::utilities::notify!("Shouldn't be here");
+ crate::utilities::notify!("Shouldn't be applying `Event::EndOfControlFlow`");
}
- Event::FinalEvent(final_event) => {
- let application_result = match final_event {
- FinalEvent::Break { carry, position } => ApplicationResult::Break {
- // TODO is this correct?
- carry: carry.saturating_sub(target.get_iteration_depth()),
- position: *position,
- },
- FinalEvent::Continue { carry, position } => ApplicationResult::Continue {
- // TODO is this correct?
- carry: carry.saturating_sub(target.get_iteration_depth()),
- position: *position,
- },
- FinalEvent::Throw { thrown, position } => {
- let substituted_thrown =
- substitute(*thrown, type_arguments, top_environment, types);
- if target.in_unconditional() {
- let value = TypeStringRepresentation::from_type_id(
- substituted_thrown,
- // TODO is this okay?
- top_environment,
- types,
- false,
- );
- errors.errors.push(FunctionCallingError::UnconditionalThrow {
- value,
- call_site,
- });
+ Event::Miscellaneous(misc) => match misc {
+ super::MiscellaneousEvents::Has { on, publicity, under, into } => {
+ let on = substitute(*on, type_arguments, top_environment, types);
+ let under = under.substitute(type_arguments, top_environment, types);
+
+ let has = crate::features::in_operator(
+ (*publicity, &under),
+ on,
+ top_environment,
+ types,
+ );
+
+ type_arguments.arguments.insert(*into, has);
+ }
+ super::MiscellaneousEvents::Delete { on, publicity, under, into, position } => {
+ let on = substitute(*on, type_arguments, top_environment, types);
+ let under = under.substitute(type_arguments, top_environment, types);
+
+ match crate::features::delete_operator(
+ (*publicity, under),
+ on,
+ *position,
+ top_environment,
+ types,
+ ) {
+ Ok(result) => {
+ if let Some(into) = into {
+ type_arguments.arguments.insert(*into, result);
+ }
}
- ApplicationResult::Throw { thrown: substituted_thrown, position: *position }
- }
- FinalEvent::Return { returned, position } => {
- let substituted_returned =
- substitute(*returned, type_arguments, top_environment, types);
- ApplicationResult::Return {
- returned: substituted_returned,
- position: *position,
+ Err(err) => {
+ diagnostics.errors.push(match err {
+ CannotDeleteFromError::Constraint { constraint, position } => {
+ FunctionCallingError::DeleteConstraint {
+ constraint,
+ delete_position: position,
+ call_site: input.call_site,
+ }
+ }
+ CannotDeleteFromError::NonConfigurable { position: _ } => {
+ todo!()
+ }
+ });
+
+ if let Some(into) = into {
+ type_arguments.arguments.insert(*into, TypeId::ERROR_TYPE);
+ }
}
}
- };
- return Some(if let Some((on, trailing)) = trailing {
- ApplicationResult::Or {
+ }
+ super::MiscellaneousEvents::RegisterProperty {
+ on,
+ publicity,
+ under,
+ value,
+ position,
+ } => {
+ let on = substitute(*on, type_arguments, top_environment, types);
+
+ // TODO temp fix for closures
+ let on = if let Type::PartiallyAppliedGenerics(PartiallyAppliedGenerics {
on,
- truthy_result: Box::new(trailing),
- otherwise_result: Box::new(application_result),
- }
- } else {
- application_result
- });
- }
- }
- idx += 1;
- }
- None
-}
+ arguments: _,
+ }) = types.get_type_by_id(on)
+ {
+ *on
+ } else {
+ on
+ };
-/// For loops and recursion need to evaluate events. This version does that but assumes many times
-///
-/// - TODO more might need covering
-/// - TODO `_this_value` is not being used
-#[allow(clippy::used_underscore_binding)]
-pub(crate) fn apply_events_unknown(
- events: &[Event],
- _this_value: ThisValue,
- type_arguments: &mut SubstitutionArguments,
- environment: &mut Environment,
- target: &mut InvocationContext,
- types: &mut TypeStore,
-) {
- let mut idx = 0;
- while idx < events.len() {
- match &events[idx] {
- Event::ReadsReference { reflects_dependency, reference, .. } => {
- if let (Some(reflects_dependency), RootReference::Variable(variable)) =
- (reflects_dependency, reference)
- {
- // TODO this is okay for loops, not sure about other cases of this function
- crate::utilities::notify!(
- "Setting loop variable here {:?}",
- reflects_dependency
+ let under = under.substitute(type_arguments, top_environment, types);
+ let value = match value {
+ PropertyValue::Value(value) => PropertyValue::Value(substitute(
+ *value,
+ type_arguments,
+ top_environment,
+ types,
+ )),
+ value => {
+ crate::utilities::notify!("TODO value {:?}", value);
+ value.clone()
+ }
+ };
+
+ target.get_latest_info(top_environment).register_property(
+ on,
+ *publicity,
+ under.clone(),
+ value.clone(),
+ *position,
);
- target
- .get_latest_info(environment)
- .variable_current_value
- .insert(*variable, *reflects_dependency);
}
- }
- Event::Getter { reflects_dependency, .. } => {
- // Evaluates getters
- if let Some(_reflects_dependency) = reflects_dependency {
- crate::utilities::notify!("Run getters ???");
- // let on = substitute(on, type_arguments, environment, types);
- // let under = match under {
- // under @ PropertyKey::String(_) => under,
- // PropertyKey::Type(under) => {
- // PropertyKey::Type(substitute(under, type_arguments, environment, types))
- // }
- // };
- // get_property(
- // on,
- // publicity,
- // &under,
- // None,
- // top_environment,
- // target,
- // types,
- // position,
- // bind_this,
- // )
+ super::MiscellaneousEvents::CreateConstructor {
+ referenced_in_scope_as,
+ function,
+ } => {
+ let new_function_ty = types.register_type(Type::SpecialObject(
+ SpecialObject::Function(*function, Default::default()),
+ ));
+ // Apply curring
+ let new_function_ty = if type_arguments.closures.is_empty() {
+ new_function_ty
+ } else {
+ types.register_type(Type::PartiallyAppliedGenerics(PartiallyAppliedGenerics {
+ on: new_function_ty,
+ arguments: crate::types::generics::generic_type_arguments::GenericArguments::Closure(type_arguments.closures.clone()),
+ }))
+ };
+ type_arguments.set_during_application(*referenced_in_scope_as, new_function_ty);
+ }
+ },
+ Event::FinalEvent(final_event) => {
+ // I think this is okay
+ if !unknown_mode {
+ let application_result = match final_event {
+ FinalEvent::Break { carry, position } => ApplicationResult::Break {
+ // TODO is this correct?
+ carry: carry.saturating_sub(target.get_iteration_depth()),
+ position: *position,
+ },
+ FinalEvent::Continue { carry, position } => ApplicationResult::Continue {
+ // TODO is this correct?
+ carry: carry.saturating_sub(target.get_iteration_depth()),
+ position: *position,
+ },
+ FinalEvent::Throw { thrown, position } => {
+ let substituted_thrown =
+ substitute(*thrown, type_arguments, top_environment, types);
+ if target.in_unconditional() {
+ let value = TypeStringRepresentation::from_type_id(
+ substituted_thrown,
+ // TODO is this okay?
+ top_environment,
+ types,
+ false,
+ );
+ let warning =
+ crate::diagnostics::TypeCheckWarning::ConditionalExceptionInvoked {
+ value,
+ call_site: input.call_site,
+ };
+ diagnostics.warnings.push(warning);
+ }
+ ApplicationResult::Throw {
+ thrown: substituted_thrown,
+ position: *position,
+ }
+ }
+ FinalEvent::Return { returned, position } => {
+ let substituted_returned =
+ substitute(*returned, type_arguments, top_environment, types);
+ ApplicationResult::Return {
+ returned: substituted_returned,
+ position: *position,
+ }
+ }
+ };
+ return Some(if let Some((on, trailing)) = trailing {
+ ApplicationResult::Or {
+ on,
+ truthy_result: Box::new(trailing),
+ otherwise_result: Box::new(application_result),
+ }
+ } else {
+ application_result
+ });
}
}
- Event::SetsVariable(variable, _value, _) => {
- // crate::utilities::notify!("Here");
- // let new_value =
- // crate::types::get_constraint(*value, types).map_or(*value, |value| {
- // types.register_type(Type::RootPolyType(crate::types::PolyNature::Open(
- // value,
- // )))
- // });
-
- crate::utilities::notify!("Here");
- environment.possibly_mutated_variables.insert(*variable);
-
- // // Don't like this but I think it is okay
- // environment.info.variable_current_value.insert(*variable, new_value);
- }
- Event::Setter { on, under, new, initialization: _, publicity, position } => {
- let on = substitute(*on, type_arguments, environment, types);
- let new_value = match new {
- PropertyValue::Value(new) => {
- let new = crate::types::get_constraint(*new, types).map_or(*new, |value| {
- types.register_type(Type::RootPolyType(crate::types::PolyNature::Open(
- value,
- )))
- });
- PropertyValue::Value(new)
- }
- // TODO
- PropertyValue::Getter(_)
- | PropertyValue::Setter(_)
- | PropertyValue::Deleted => new.clone(),
- PropertyValue::ConditionallyExists { .. } => todo!(),
- };
- let under = match under {
- under @ PropertyKey::String(_) => under.clone(),
- PropertyKey::Type(under) => {
- PropertyKey::Type(substitute(*under, type_arguments, environment, types))
- }
- };
-
- environment
- .info
- .register_property(on, *publicity, under, new_value, false, *position);
- }
- Event::CallsType { .. } => {
- crate::utilities::notify!("TODO ?");
- }
- Event::Conditionally { truthy_events, otherwise_events, .. } => {
- let (truthy_events, otherwise_events) =
- (*truthy_events as usize, *otherwise_events as usize);
-
- let offset = idx + 1;
- let truthy_events_slice = &events[offset..(offset + truthy_events)];
- let otherwise_events_slice =
- &events[(offset + truthy_events)..(offset + truthy_events + otherwise_events)];
-
- // TODO think this is correct...?
- apply_events_unknown(
- truthy_events_slice,
- _this_value,
- type_arguments,
- environment,
- target,
- types,
- );
- apply_events_unknown(
- otherwise_events_slice,
- _this_value,
- type_arguments,
- environment,
- target,
- types,
- );
- idx += truthy_events + otherwise_events;
- }
- Event::CreateObject { .. } => {
- crate::utilities::notify!("Creating object");
- }
- Event::FinalEvent(..) => {
- crate::utilities::notify!("final events");
- }
- Event::Iterate { .. } => {
- // This should be fine?
- // for event in iterate_over.to_vec() {
- // apply_event_unknown(
- // event,
- // this_value,
- // type_arguments,
- // environment,
- // target,
- // types,
- // )
- // }
- crate::utilities::notify!("Iterate trap anytime");
- }
- Event::ExceptionTrap { .. } => {
- crate::utilities::notify!("Exception trap anytime");
- }
- Event::EndOfControlFlow { .. } => {
- crate::utilities::notify!("Shouldn't be here");
- }
- Event::RegisterVariable { .. } => {}
}
idx += 1;
}
+ None
}
diff --git a/checker/src/events/mod.rs b/checker/src/events/mod.rs
index b5a1bd00..a376db6f 100644
--- a/checker/src/events/mod.rs
+++ b/checker/src/events/mod.rs
@@ -3,14 +3,14 @@
//! Events is the general name for the IR (intermediate representation) of impure operations. Effect = Events of a function
pub(crate) mod application;
+pub mod printing;
use crate::{
context::get_on_ctx,
features::{functions::ClosedOverVariables, iteration::IterationKind},
types::{
- calling::CalledWithNew,
- functions::SynthesisedArgument,
- properties::{PropertyKey, PropertyValue, Publicity},
+ calling::{Callable, CalledWithNew, SynthesisedArgument},
+ properties::{AccessMode, PropertyKey, PropertyValue, Publicity},
TypeId,
},
FunctionId, GeneralContext, SpanWithSource, VariableId,
@@ -62,30 +62,25 @@ pub enum Event {
reflects_dependency: Option,
publicity: Publicity,
position: SpanWithSource,
- bind_this: bool,
+ mode: AccessMode,
},
- /// All changes to the value of a property
+ /// All assignments to the value of a property. TODO explain others for defining getters etc
Setter {
on: TypeId,
under: PropertyKey<'static>,
- // Can be a getter through define property
- new: PropertyValue,
- /// THIS DOES NOT CALL SETTERS, JUST SETS VALUE!
- /// TODO this is [define] property
- /// see
- initialization: bool,
+ new: TypeId,
publicity: Publicity,
position: SpanWithSource,
},
/// This includes closed over variables, anything dependent
CallsType {
- on: TypeId,
+ on: Callable,
with: Box<[SynthesisedArgument]>,
reflects_dependency: Option,
timing: CallingTiming,
called_with_new: CalledWithNew,
possibly_thrown: Option,
- position: SpanWithSource,
+ call_site: SpanWithSource,
},
/// Run events conditionally
Conditionally {
@@ -148,7 +143,7 @@ pub enum Event {
/// `None` for `let x;`
initial_value: Option,
},
-
+ Miscellaneous(MiscellaneousEvents),
/// TODO was trying to avoid
EndOfControlFlow(u32),
}
@@ -166,7 +161,33 @@ impl From for Event {
}
}
-/// Nothing runs after this event
+/// Some of these are [`crate::features::objects::Proxy`] traps
+#[derive(Debug, Clone, binary_serialize_derive::BinarySerializable)]
+pub enum MiscellaneousEvents {
+ /// Also for
+ Has { on: TypeId, publicity: Publicity, under: PropertyKey<'static>, into: TypeId },
+ /// Very similar to [`MiscellaneousEvents::Has`] but deletes the properties
+ /// Also for
+ Delete {
+ on: TypeId,
+ publicity: Publicity,
+ under: PropertyKey<'static>,
+ into: Option,
+ position: SpanWithSource,
+ },
+ /// :/
+ RegisterProperty {
+ on: TypeId,
+ publicity: Publicity,
+ under: PropertyKey<'static>,
+ value: PropertyValue,
+ position: SpanWithSource,
+ },
+ /// Creates a new function or class
+ CreateConstructor { referenced_in_scope_as: TypeId, function: FunctionId },
+}
+
+/// A break in application
#[derive(Debug, Clone, Copy, binary_serialize_derive::BinarySerializable)]
pub enum FinalEvent {
Return {
@@ -188,6 +209,9 @@ pub enum FinalEvent {
position: SpanWithSource,
},
// Yield {
+ // value: TypeId,
+ // returns: TypeId,
+ // position: SpanWithSource,
// }
}
diff --git a/checker/src/events/printing.rs b/checker/src/events/printing.rs
new file mode 100644
index 00000000..9e128329
--- /dev/null
+++ b/checker/src/events/printing.rs
@@ -0,0 +1,200 @@
+use std::collections::HashSet;
+
+use super::{Event, FinalEvent};
+use crate::{
+ context::InformationChain,
+ events::CallingTiming,
+ types::{
+ calling::Callable,
+ printing::{print_property_key_into_buf, print_type_into_buf},
+ properties::PropertyKey,
+ GenericChain, TypeStore,
+ },
+};
+
+pub fn debug_effects(
+ buf: &mut String,
+ events: &[Event],
+ types: &TypeStore,
+ info: &C,
+ depth: u8,
+ debug: bool,
+) {
+ use std::fmt::Write;
+
+ let args = GenericChain::None;
+
+ let mut idx = 0;
+
+ while idx < events.len() {
+ for _ in 0..depth {
+ buf.push('\t');
+ }
+ let event = &events[idx];
+ match event {
+ Event::ReadsReference { reference, reflects_dependency, position: _ } => {
+ write!(buf, "read '{reference:?}' into {reflects_dependency:?}").unwrap();
+ }
+ Event::SetsVariable(variable, value, _) => {
+ write!(buf, "{variable:?}' = ").unwrap();
+ print_type_into_buf(*value, buf, &mut HashSet::new(), args, types, info, debug);
+ }
+ Event::Getter {
+ on,
+ under,
+ reflects_dependency,
+ publicity: _,
+ position: _,
+ mode: _,
+ } => {
+ buf.push_str("read ");
+ print_type_into_buf(*on, buf, &mut HashSet::new(), args, types, info, debug);
+ if let PropertyKey::String(_) = under {
+ buf.push('.');
+ }
+ print_property_key_into_buf(
+ under,
+ buf,
+ &mut HashSet::new(),
+ args,
+ types,
+ info,
+ debug,
+ );
+ write!(buf, " into {reflects_dependency:?}").unwrap();
+ }
+ Event::Setter { on, under, new, publicity: _, position: _ } => {
+ print_type_into_buf(*on, buf, &mut HashSet::new(), args, types, info, debug);
+ buf.push('[');
+ print_property_key_into_buf(
+ under,
+ buf,
+ &mut HashSet::default(),
+ args,
+ types,
+ info,
+ debug,
+ );
+ buf.push_str("] = ");
+ print_type_into_buf(*new, buf, &mut HashSet::new(), args, types, info, debug);
+ }
+ Event::CallsType {
+ on,
+ with: _,
+ reflects_dependency,
+ timing,
+ called_with_new: _,
+ call_site: _,
+ possibly_thrown: _,
+ } => {
+ buf.push_str("call ");
+ match on {
+ Callable::Fixed(function, _) => {
+ write!(buf, " {function:?} ").unwrap();
+ }
+ Callable::Type(on) => {
+ let mut cycles = HashSet::new();
+ print_type_into_buf(*on, buf, &mut cycles, args, types, info, debug);
+ }
+ }
+ write!(buf, " into {reflects_dependency:?} ",).unwrap();
+ buf.push_str(match timing {
+ CallingTiming::Synchronous => "now",
+ CallingTiming::QueueTask => "queue",
+ CallingTiming::AtSomePointManyTimes => "sometime",
+ });
+ // TODO args
+ }
+ Event::Conditionally { condition, truthy_events, otherwise_events, position: _ } => {
+ let truthy_events = *truthy_events as usize;
+ let otherwise_events = *otherwise_events as usize;
+
+ buf.push_str("if ");
+ print_type_into_buf(*condition, buf, &mut HashSet::new(), args, types, info, debug);
+ buf.push_str(" then\n");
+
+ let events_if_true = &events[(idx + 1)..=(idx + truthy_events)];
+ if truthy_events != 0 {
+ debug_effects(buf, events_if_true, types, info, depth + 1, debug);
+ }
+
+ if otherwise_events != 0 {
+ let start = idx + truthy_events + 1;
+ let otherwise = &events[(start)..(start + otherwise_events)];
+ for _ in 0..depth {
+ buf.push('\t');
+ }
+ buf.push_str("else\n");
+ debug_effects(buf, otherwise, types, info, depth + 1, debug);
+ }
+ idx += truthy_events + otherwise_events + 1;
+ continue;
+ }
+ Event::CreateObject { prototype: _, referenced_in_scope_as, position: _ } => {
+ write!(buf, "create object as {referenced_in_scope_as:?}").unwrap();
+ }
+ Event::Iterate { iterate_over, initial: _, kind: _ } => {
+ buf.push_str("iterate\n");
+ let inner_events = &events[(idx + 1)..(idx + 1 + *iterate_over as usize)];
+ debug_effects(buf, inner_events, types, info, depth + 1, debug);
+ idx += *iterate_over as usize + 1;
+ continue;
+ }
+ Event::FinalEvent(FinalEvent::Throw { thrown, .. }) => {
+ buf.push_str("throw ");
+ print_type_into_buf(*thrown, buf, &mut HashSet::new(), args, types, info, debug);
+ }
+ Event::FinalEvent(FinalEvent::Break { .. }) => {
+ buf.push_str("break");
+ }
+ Event::FinalEvent(FinalEvent::Continue { .. }) => {
+ buf.push_str("continue");
+ }
+ Event::FinalEvent(FinalEvent::Return { returned, position: _ }) => {
+ buf.push_str("return ");
+ print_type_into_buf(*returned, buf, &mut HashSet::new(), args, types, info, debug);
+ }
+ Event::ExceptionTrap { .. } => todo!(),
+ Event::RegisterVariable { name, .. } => {
+ write!(buf, "register variable {name}").unwrap();
+ }
+ Event::EndOfControlFlow(_) => {
+ buf.push_str("end");
+ }
+ Event::Miscellaneous(misc) => match misc {
+ super::MiscellaneousEvents::Has { .. } => {
+ buf.push_str("Has");
+ }
+ super::MiscellaneousEvents::Delete { .. } => {
+ buf.push_str("Delete");
+ }
+ super::MiscellaneousEvents::RegisterProperty {
+ on,
+ publicity: _,
+ under,
+ value,
+ position: _,
+ } => {
+ print_type_into_buf(*on, buf, &mut HashSet::new(), args, types, info, debug);
+ buf.push('[');
+ print_property_key_into_buf(
+ under,
+ buf,
+ &mut HashSet::default(),
+ args,
+ types,
+ info,
+ debug,
+ );
+ buf.push_str("] = ");
+ write!(buf, "{value:?}").unwrap();
+ }
+ super::MiscellaneousEvents::CreateConstructor { .. } => {
+ buf.push_str("create constructor");
+ }
+ },
+ }
+ buf.push('\n');
+ idx += 1;
+ }
+}
diff --git a/checker/src/features/assignments.rs b/checker/src/features/assignments.rs
index d9742156..486aab57 100644
--- a/checker/src/features/assignments.rs
+++ b/checker/src/features/assignments.rs
@@ -18,13 +18,18 @@ pub enum Assignable {
#[derive(Clone)]
pub enum Reference {
Variable(String, SpanWithSource),
- Property { on: TypeId, with: PropertyKey<'static>, publicity: Publicity, span: SpanWithSource },
+ Property {
+ on: TypeId,
+ with: PropertyKey<'static>,
+ publicity: Publicity,
+ position: SpanWithSource,
+ },
}
pub enum AssignableObjectDestructuringField {
/// `{ x: y }`
Mapped {
- on: PropertyKey<'static>,
+ key: PropertyKey<'static>,
name: Assignable