union + distributive conditional types + fix call convention

marcj · Jun 8, 2022 · c5ddd6c · c5ddd6c
1 parent 3a46c8d
commit c5ddd6c
Show file tree

Hide file tree

Showing 11 changed files with 584 additions and 126 deletions.
diff --git a/src/checker/checks.h b/src/checker/checks.h
@@ -15,6 +15,41 @@ namespace ts::vm {
             if (right->kind == TypeKind::Literal) return to<TypeLiteral>(right)->type == TypeLiteralType::String;
         }
 
+        if (left->kind == TypeKind::Number) {
+            if (right->kind == TypeKind::Number) return true;
+            if (right->kind == TypeKind::Literal) return to<TypeLiteral>(right)->type == TypeLiteralType::Number;
+        }
+
+        if (left->kind == TypeKind::Literal && right->kind == TypeKind::Literal) {
+            return to<TypeLiteral>(left)->type == to<TypeLiteral>(right)->type &&
+                    to<TypeLiteral>(left)->literal == to<TypeLiteral>(right)->literal;
+        }
+
+        if (left->kind == TypeKind::Union) {
+            if (right->kind != TypeKind::Union) {
+                for (auto &&l: to<TypeUnion>(left)->types) {
+                    if (isAssignable(l, right)) return true;
+                }
+                return false;
+            } else {
+                //e.g.: string|number = string|boolean
+                const auto leftTypes = to<TypeUnion>(left)->types;
+                const auto rightTypes = to<TypeUnion>(right)->types;
+
+                for (auto &&r: rightTypes) {
+                    bool valid = false;
+                    for (auto &&l: leftTypes) {
+                        if (isAssignable(l, r)) {
+                            valid = true;
+                            break;
+                        };
+                    }
+                    if (!valid) return false;
+                }
+                return true;
+            }
+        }
+
         return false;
     }
 }
diff --git a/src/checker/compiler.h b/src/checker/compiler.h
diff --git a/src/checker/instructions.h b/src/checker/instructions.h
@@ -37,9 +37,16 @@ namespace ts::instructions {
 
         Class,
 
+        Tuple,
+        TupleMember,
+
         Union,
         Intersection,
 
+        Extends, //expected 2 entries on the stack
+        Condition, //expected 3 entries on the stack
+        JumpCondition, //expected 1 entry on the stack + two uint16 parameters
+
         /**
          * Stack parameter. For each JS variable, JS function, as well as type variables (mapped-type variable for example).
          *
@@ -50,6 +57,17 @@ namespace ts::instructions {
          */
         Var,
 
+        /**
+         * Makes sure that in the current variable slot is a type placed if nothing was provided as parameter.
+         *
+         * For reach type argument like here `T` a TypeArgument OP is generated.
+         * Different to Var OP since Var does reserve an entry on the stack, whereas TypeArgument does nothing on the stack per default.
+         * ```typescript
+         * type A<T> = T;
+         * ```
+         */
+        TypeArgument,
+
         /**
          * Reserves a type variable on the stack, which contains a type object. Unknown as default.
          *
@@ -63,7 +81,9 @@ namespace ts::instructions {
         Return,
 
         Jump,
+        Distribute, //calls a subroutine for each union member. one parameter (address to subroutine)
         Call //call a subroutine and push the result on the stack
+
     };
 }
 

diff --git a/src/checker/type_objects.h b/src/checker/type_objects.h
@@ -81,18 +81,19 @@ namespace ts::vm {
     struct TypeString: BrandKind<TypeKind::String, Type> {};
     struct TypeNumber: BrandKind<TypeKind::Number, Type> {};
     struct TypeBigint: BrandKind<TypeKind::Bigint, Type> {};
-    struct TypeBoolean: BrandKind<TypeKind::Boolean, Type> {};
+    struct TypeBoolean: BrandKind<TypeKind::Boolean, Type> { };
     struct TypeSymbol: BrandKind<TypeKind::Symbol, Type> {};
     struct TypeNull: BrandKind<TypeKind::Null, Type> {};
     struct TypeUndefined: BrandKind<TypeKind::Undefined, Type> {};
 
-    struct TypeUnion: BrandKind<TypeKind::Undefined, Type> {
+    struct TypeUnion: BrandKind<TypeKind::Union, Type> {
         vector<shared<Type>> types;
     };
 
     enum class TypeLiteralType {
         Number,
         String,
+        Boolean,
         Bigint
     };
 
@@ -116,13 +117,13 @@ namespace ts::vm {
     };
 
     template<class T>
-    sharedOpt<T> to(sharedOpt<Type> p) {
+    sharedOpt<T> to(const sharedOpt<Type> &p) {
         if (!p) return nullptr;
         if (T::KIND != TypeKind::Unknown && p->kind != T::KIND) return nullptr;
         return reinterpret_pointer_cast<T>(p);
     }
 
-    string_view stringify(shared < Type > type) {
+    string stringify(shared < Type > type) {
         //todo: recursive types
 
         switch (type->kind) {
@@ -139,8 +140,11 @@ namespace ts::vm {
                 auto literal = to<TypeLiteral>(type);
                 switch (literal->type) {
                     case TypeLiteralType::String: return string("\"").append(literal->literal).append("\"");
-                    case TypeLiteralType::Number: return literal->literal;
+                    case TypeLiteralType::Number: return string(literal->literal);
+                    case TypeLiteralType::Bigint: return string(literal->literal);
+                    case TypeLiteralType::Boolean: return string(literal->literal);
                 }
+                return "unknown-literal";
             }
             case TypeKind::Union: {
                 auto t = to<TypeUnion>(type);