This should fail because a generator function uses the item from Iterable as yield type.
i.e., g3 is inferred to emit a string as an item, and the inferred generator (Generator<number, any, undefined>) is assigned to BadGenerator.

It should file with

tests/tsc/types/builtin/generator/bad/1.ts:2:24 - error TS2322: Type 'Generator<string, any, undefined>' is not assignable to type 'BadGenerator'.
  The types returned by 'next(...)' are incompatible between these types.
    Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<number, any>'.
      Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
        Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
          Type 'string' is not assignable to type 'number'.

But currently, stc fails to emit an error because stc uses the Iterator interface instead of the Iterable interface while inferring the yield type.

The lines above should not report an error, but stc currently emits

The cause is

and it should be fixed to allow assignment to nested modules

Currently, we need to instantiate the full interface to infer the type of parameter.
This is too inefficient, and it can be done by

• Attach id to type parameters and store type parameter information in the Scope.

• Store type arguments in types like Interface, Class, ..etc

The first option seems better.

The code above should fail with TS2348, but currently it failes with TS2349

It has the context of tried to calculate return type, which is used at

But error is NoCallablePropertyWithName, which is TS2349, and

So we should modify

to use different error variant.

There's some logic to assign parameters in a reverse direction, but I'm not sure when it's applied.

I think the current logic is wrong, but not sure as I don't know enough about variance.
To be exact, I understood variance itself, but I'm not sure which variance I should use for an assignment in form of LHS = RHS as there are two types, and therefore two variances.

We should remove ClassInstance and add ClassDef type.
ClassDef is used for accessing static properties and Class is used for accessing non-static properties.

stc_ts_file_analyzer:

• find_imported_var: Support namespace imports.

stc_ts_type_checker:

• Process all typings before processing user-specified files. This is required to handle modules created using declare module 'http' or declare namespace NodeJs.

This should not error, but currently, stc emits TupleIndexError

We should recover from the error based on the variant at

I tried it, but for some unknown reasons there were regressions in performance and passing test list.

The branch is at https://github.com/kdy1/stc/tree/swc-update, and I'm planning to retry it in the future

This should success.

access_property of ((BarProps#1 & object) | {}) is expected to fail, because {} does not have the property.
But the type of fooProps should be (BarProps#1 & object) (without union)

I think the logic at

This causes problems for check.sh.

We should make it deterministic.

• ValidationResult => VResult
• derive(Is) of Type should be replaced with a smarter implementation, which is aware of normalization.
• Type#normalize should be renamed

The type of o6<number>()?.["x"]; above should be number | undefined, but currently it's number.

Relevant code for optional chaining is

After updating testing_macros upto ^0.2.0, this error will be resolved.
Currently we are using v0.1.2 instead which seems to be failed to compile.

   Compiling testing_macros v0.1.2
error[E0432]: unresolved import `proc_macro2::SourceFile`
 --> /Users/flow/.cargo/registry/src/github.com-1ecc6299db9ec823/testing_macros-0.1.2/src/fixture.rs:6:19
  |
6 | use proc_macro2::{SourceFile, Span};
  |                   ^^^^^^^^^^ no `SourceFile` in the root

error[E0599]: no method named `source_file` found for struct `proc_macro2::Span` in the current scope
  --> /Users/flow/.cargo/registry/src/github.com-1ecc6299db9ec823/testing_macros-0.1.2/src/lib.rs:58:34
   |
58 |     let file = Span::call_site().source_file();
   |                                  ^^^^^^^^^^^ method not found in `proc_macro2::Span`

Some errors have detailed explanations: E0432, E0599.
For more information about an error, try `rustc --explain E0432`.
error: could not compile `testing_macros` due to 2 previous errors

Compile time is delaying development.

Crates

traits

• Defines ExpandRef
• Defines Assign
• Defines InferType

assignments

• Depends on traits.

Handles assignments

generics

Handles type inference.

Module graph should return RModule along with Arc<SourceMap>, Arc<SourceFile>.
It will allow using types from cache without degrading span.

All types should have the same struct.
This is required to preserve current semantics.

And it should have fields for each type.

pub struct Metadata {
    pub type_lit: TypeLitMetadata,
}

derivedClassTransitivity.ts:

// subclassing is not transitive when you can remove required parameters and add optional parameters

class C {
    foo(x: number) { }
}

class D extends C {
    foo() { } // ok to drop parameters
}

class E extends D {
    foo(x?: string) { } // ok to add optional parameters
}

var c: C;
var d: D;
var e: E;
c = e;
var r = c.foo(1);
var r2 = e.foo('');

We need logic to compare private properties.

We should store the id of declaring class in properties, because properties from multiple class can be mixed.

assign: (span: Span, l: &Type, r: &Type, opts: AssignOpts)

Size regressed from 8MB to 12MB due to dudykr/stc-archive#31.
This is because of Visit being shared between types and ast nodes.

This can be fixed by macros like noop_{visit, visit_mut, fold}_{ast, type}.
As this is not critical for development, I merged the pr

We are validating assign expressions twice, and this is super annoying

CowArcVec would be useful

BoxedCowArc is boxed variant

type TypePtr = BoxedCowArc

I postponed it from #170 because I have another item to work on

Basically,

//@strict: true

type ArgsUnion = [number, string] | [number, Error];
type TupleUnionFunc = (...params: ArgsUnion) => number;

const funcUnionTupleRest: TupleUnionFunc = (...params) => {
  const [num, strOrErr] = params;
  return num;
};


export { }

should work.

It can be done by fixing code at

Generated .d.ts file differs if strict mode is enabled.

I made a mistake while working on #15. I forgot splitting env.

This line should fail with TS2708, but it fails with TS2539.

The problematic code is at

and we should use Errorr::convert_err to adjust the error variant.

We need a debug impl which is replaced with dummy impl on release build.

Currently, type parameters are incorrectly stored, but when I tried storing them recursively, it resulted in a stack overflow.

https://github.com/swc-project/stc/blob/76e1a7d0c48ea2c9e78e97fba4f32187d31cd625/typescript/file_analyzer/src/analyzer/convert/mod.rs#L120-L131

I tried preventing stack overflow, but the 'validity' of type can't be ignored. Especially, Fixer cannot give up fixing types, because it makes validity assertion of a type fail.

Solutions

Solution 1: Allow invalid state

Allowing the constraints of type parameters to be invalid and fixing them each time contraint is used can be a solution, but it does not seem like a good solution.

Solution 2: Use Type::Ref for constraints.

This would make code dirty, but it would be easy to handle infinite recursion because many methods have their own logic to prevent infinite recursions. (fix() does not have way to prevent recursion, and it's the problem)

Just wondering how to use stc, at its current state.
Do I need to consume it as a library or run it through a test shim?

I cloned the repository, updated the dependencies through yarn and compiled the project with rustc build.
Alas, the resulting stc binary only contains two subcommands (help and iterate) and simply providing a TypeScript source file simply returns a Found argument '<pathToTSFile>' which wasn't expected, or isn't valid in this context

• infer_type: Fast path for Type::Mapped with Type::Array.
• normalize: Partial expansion.
• fix: Make it shallow.
• fix: Reduce call.
• normalize: Cache(?).

expr/call_new.rs

• Skip reevaluation if there's no argument requires reevaluation.

loops.rs

• Use result from first run if no type fact is generated.

In the files above, the assignment should succeed because Tag1 and Tag2 are enum without an initializer, and enums without initializers are numbers while reducing.

This can be done by checking for enums in

pub struct AType {
    arc: Either<Type, Arc<Type>>,
}

AType.normalize() returns type and Arc<Type> is used while cloning.

This line should not error, but stc fails to validate it because stc thinks the type of a1 is string[] instead of [string, boolean].

I think the problematic code is

Span is too implicit and it causes some bugs.

Required metadata

All metadata will be implemented as a field metadata and all metadata structs must always return true for TypeEq and EqIgnoreSpan.

Type::Keyword:

• Implicit.

Type::TypeLit:

• is_exact: Used for assignemnts. If is_exact is false, unhandled rhs will be ignored.

I'll do this after #13.

I think AGPL 3.0 will not work for many vendors, but I don't want to change the license at now.

(Actually, I rebased the whole repo to add the AGPL License file to the first commit)

See: https://github.com/denoland/rusty_v8/releases

This line should not report an argumentnt error because fields are optional.

The type of arguments are correctly inferred as [any, any, any, any] but we should allow assignment of [1] to [any, any, any, any].

The assignment logic for tuple should be aware of any or undefined and allow the length to mismatch for these cases.

We currently store types as vector, but we should store types as intersection.

It will allow preprocessing builtin types

Features

• Autocompletion in

  • Class name

    • from file name.

  • Super class

  • Types

It can be inferred from usages. (including methods, as stc is fast)

• Generate function when a function is not defined.

• Generate method when a method is not defined.

• import boss: Block @material-ui/core from being imported.

• auto-recompile for kind of shared modules (path dependencies).

• Run directly from editor.
  -[ ] Run tests from editor.

• Actual type information in generic on hover.

• Type inference issue

The line above should not error because LHS is a rest pattern.

But currently stc fails with an error, because of the code below

This is quite similar to #182, though.

Currently there's no clear way to distinguish typeof a === 'string' || typeof a === ' number' and typeof a === 'string' && typeof a === ' number'