Fixing union types (#154)

* some fixes

* progress of fixes

* progress of fixes to union and null compare

* more fixes to safe cast and global vars

* progress of fixes

* implemented safe type for field access

* refactored tests

* fix for safe cast test

* progress of implementing safe type for field access

* update test

* improved safe type for field access

* added some code to improve dbg experience

* refactoring

* added test

* added code to support amp amp in safe types

* progress of adding new internal commands

* progress of adding inline asm

* finished inline asm

* added code for call intrinsic

* added fence command

* added test

* added atomicrmw command

* updated cmpxchg

* refactoring and implementing atomic vars

* progress of implementing atomic for vars

* added initial atomic attributes

* added alignment for load store when atomic

* progress of adding attributes to load store

* added load store attrs with correct values

* updated build script

Author: ASDAlexander77

tag.bat

@@ -1,2 +1,2 @@
-git tag -a v0.0-pre-alpha65 -m "pre alpha v0.0-65"
+git tag -a v0.0-pre-alpha66 -m "pre alpha v0.0-66"
 git push origin --tags

tag_del.bat

@@ -1,2 +1,2 @@
-git push --delete origin v0.0-pre-alpha65
-git tag -d v0.0-pre-alpha65
+git push --delete origin v0.0-pre-alpha66
+git tag -d v0.0-pre-alpha66

tsc/include/TypeScript/DOM.h

@@ -35,14 +35,17 @@ class VariableDeclarationDOM
     using TypePtr = std::shared_ptr<VariableDeclarationDOM>;
 
     VariableDeclarationDOM(StringRef name, mlir::Type type, mlir::Location loc, Expression initValue = undefined)
-        : name(name), type(type), loc(loc), initValue(initValue), captured(false), ignoreCapturing(false), _using(false), readWrite(false)
+        : name(name), type(type), loc(loc), initValue(initValue), captured(false), ignoreCapturing(false), _using(false), readWrite(false),
+        atomic(false), ordering(0), syncscope(StringRef()), volatile_(false),
+        nonTemporal(false), invariant(false)
     {
     }
 
     StringRef getName() const
     {
         return name;
     }
+
     const mlir::Type &getType() const
     {
         return type;
@@ -51,10 +54,12 @@ class VariableDeclarationDOM
     {
         type = type_;
     }
+
     const mlir::Location &getLoc() const
     {
         return loc;
     }
+
     const Expression &getInitValue() const
     {
         return initValue;
@@ -63,41 +68,97 @@ class VariableDeclarationDOM
     {
         return !!initValue;
     }
+
     bool getReadWriteAccess() const
     {
         return readWrite;
-    };
+    }
     void setReadWriteAccess(bool value = true)
     {
         readWrite = value;
-    };
+    }
+
     bool getCaptured() const
     {
         return captured;
-    };
+    }
     void setCaptured(bool value = true)
     {
         captured = value;
-    };
+    }
+
     bool getIgnoreCapturing()
     {
         return ignoreCapturing;
-    };
+    }
     void setIgnoreCapturing(bool value = true)
     {
         ignoreCapturing = value;
-    };
+    }
+
     bool getUsing() const
     {
         return _using;
-    };
+    }
     void setUsing(bool value = true)
     {
         _using = value;
+    }
+
+    void setAtomic(int ordering_, StringRef syncscope_)
+    {
+        atomic = true;
+        ordering = ordering_;
+        syncscope = syncscope_;
+    }
+    bool getAtomic() const
+    {
+        return atomic;
+    }
+    int getOrdering() const
+    {
+        return ordering;
+    }
+    StringRef getSyncScope() const
+    {
+        return syncscope;
+    }
+
+    bool getVolatile() const
+    {
+        return volatile_;
+    }
+    void setVolatile(bool value = true)
+    {
+        volatile_ = value;
+    };
+
+    bool getNonTemporal() const
+    {
+        return nonTemporal;
+    }
+    void setNonTemporal(bool value = true)
+    {
+        nonTemporal = value;
+    };
+
+    bool getInvariant() const
+    {
+        return invariant;
+    }
+    void setInvariant(bool value = true)
+    {
+        invariant = value;
     };
 
   protected:
     bool readWrite;
+    bool atomic;
+    int ordering;
+    StringRef syncscope;
+    bool volatile_;
+    bool nonTemporal;
+    bool invariant;
 };
 
 class FunctionParamDOM : public VariableDeclarationDOM

tsc/include/TypeScript/Defines.h

@@ -4,6 +4,12 @@
 #define IDENTIFIER_ATTR_NAME "identifier"
 #define BUILTIN_FUNC_ATTR_NAME "__builtin"
 #define GENERIC_ATTR_NAME "__generic"
+#define ATOMIC_ATTR_NAME "__atomic"
+#define ORDERING_ATTR_NAME "__ordering"
+#define SYNCSCOPE_ATTR_NAME "__syncscope"
+#define VOLATILE_ATTR_NAME "__volatile"
+#define NONTEMPORAL_ATTR_NAME "__nontemporal"
+#define INVARIANT_ATTR_NAME "__invariant"
 #define INSTANCES_COUNT_ATTR_NAME "InstancesCount"
 #define RETURN_VARIABLE_NAME ".return"
 #define CAPTURED_NAME ".captured"

tsc/include/TypeScript/LowerToLLVM/UnaryBinLogicalOrHelper.h

@@ -153,6 +153,24 @@ mlir::Value LogicOp(Operation *binOp, SyntaxKind op, mlir::Value left, mlir::Typ
     else if (isa<mlir_ts::AnyType>(leftType) || isa<mlir_ts::ClassType>(leftType) || 
                 isa<mlir_ts::OpaqueType>(leftType) || isa<mlir_ts::NullType>(leftType))
     {
+        // in case of UnionType
+        if (auto unionType = dyn_cast<mlir_ts::UnionType>(rightType))
+        {
+            ::typescript::MLIRTypeHelper mth(builder.getContext(), compileOptions);
+            mlir::Type baseType;
+            if (mth.isUnionTypeNeedsTag(loc, unionType, baseType))
+            {
+                auto tagValue = builder.create<LLVM::ExtractValueOp>(loc, llvmtch.typeConverter->convertType(mth.getStringType()), right,
+                                    MLIRHelper::getStructIndex(builder, UNION_TAG_INDEX));                
+                auto nullStr = builder.create<mlir_ts::ConstantOp>(loc, mth.getStringType(), builder.getStringAttr("null"));
+                auto cmpOp = builder.create<mlir_ts::StringCompareOp>(
+                    loc, mth.getBooleanType(), tagValue, nullStr, builder.getI32IntegerAttr((int)op));
+                return cmpOp;
+            }
+
+            return LogicOp<StdIOpTy, V1, v1, StdFOpTy, V2, v2>(binOp, op, left, baseType, right, rightType, builder, typeConverter, compileOptions);
+        }
+
         // excluded string
         auto intPtrType = llvmtch.getIntPtrType(0);
 
@@ -227,7 +245,21 @@ mlir::Value LogicOp(Operation *binOp, SyntaxKind op, mlir::Value left, mlir::Typ
         mlir::Type baseType;
         if (mth.isUnionTypeNeedsTag(loc, unionType, baseType))
         {
+            // add test to null value
+            auto isRightNullValue =
+                right.getDefiningOp<mlir_ts::NullOp>() || right.getDefiningOp<LLVM::ZeroOp>() || matchPattern(right, m_Zero());            
+            if (isRightNullValue)
+            {
+                auto tagValue = builder.create<LLVM::ExtractValueOp>(loc, llvmtch.typeConverter->convertType(mth.getStringType()), left,
+                                    MLIRHelper::getStructIndex(builder, UNION_TAG_INDEX));                
+                auto nullStr = builder.create<mlir_ts::ConstantOp>(loc, mth.getStringType(), builder.getStringAttr("null"));
+                auto cmpOp = builder.create<mlir_ts::StringCompareOp>(
+                    loc, mth.getBooleanType(), tagValue, nullStr, builder.getI32IntegerAttr((int)op));
+                return cmpOp;
+            }
+
             emitError(loc, "Not applicable logical operator for type: '") << to_print<int>(leftType) << "'";
+            return mlir::Value();
         }
 
         return LogicOp<StdIOpTy, V1, v1, StdFOpTy, V2, v2>(binOp, op, left, baseType, right, rightType, builder, typeConverter, compileOptions);