general set of fixes (#128)

* improvements

* restore

* progress of fixes

* progress of adding set lenght for string

* added set length for string to pre allocate data

* added typed sizeof

* added test for generic sizeof

* fix issue with printing object without field names

* more fixes to use {}

* reefactored using enumerate

* refactoring finished and convert from const array to string is done

* added fix for generating debug info for index type

* more fixes

* fixes to int long types

* fixes after refactirng using enumerate

* fixed issues with using optional type with union types

* fixed issue with safe cast for undefined values

* added safe cast for conditional expressions and optional values

* added test for safe cast in conditional expressions for optional values

* fix for safecast ops

* fixes

* fixed recusive conditional expressions

* progress of adding safe cast to logical ops

* improving cast of native types

* progress of implementing simpification for IfOp and LogicalBinOp

* fixes to simplification of LogicalOp

* update

* fixed issue with safe-casting from union type into smaller union type

* update

* progress

* fixes to access to array if data is optional

* more fixes to access optional type

* added test for arrray access for optional type

* fixes to array access

* progress of implementing ref for optional types

* finished refactoring loadOp to reference

* progress

* progress

* fixes

* fixed issue with optional array type

* added warning for undefined types

* update build script

Author: ASDAlexander77

tag.bat

@@ -1,2 +1,2 @@
-git tag -a v0.0-pre-alpha53 -m "pre alpha v0.0-53"
+git tag -a v0.0-pre-alpha54 -m "pre alpha v0.0-54"
 git push origin --tags

tag_del.bat

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

tsc/CMakeLists.txt

@@ -119,7 +119,11 @@ include_directories(${PROJECT_BINARY_DIR}/include)
 link_directories(${LLVM_BUILD_LIBRARY_DIR})
 add_definitions(${LLVM_DEFINITIONS})
 
-add_definitions(-D_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING)
+if (WIN32)
+else()
+	# linux
+	add_definitions(-D_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING)
+endif()
 
 # enabling testing
 enable_testing()

tsc/include/TypeScript/LowerToLLVM/CastLogicHelper.h

@@ -18,6 +18,8 @@
 #include "TypeScript/LowerToLLVM/AnyLogic.h"
 #include "TypeScript/LowerToLLVM/LLVMCodeHelperBase.h"
 
+#include "mlir/Dialect/Index/IR/IndexDialect.h"
+#include "mlir/Dialect/Index/IR/IndexOps.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 
 using namespace mlir;
@@ -92,14 +94,14 @@ class CastLogicHelper
             return castBoolToString(in);
         }
 
-        if (inType.isa<mlir::IndexType>() && isResString)
+        if (inType.isIndex() && isResString)
         {
-            return castIntToString(in, inLLVMType.getIntOrFloatBitWidth(), false);
+            return castIntToString(in, tch.getIndexTypeBitwidth(), false);
         }
 
-        if (inLLVMType.isIntOrIndex() && inType.isa<mlir::IntegerType>() && isResString)
+        if (inType.isa<mlir::IntegerType>() && isResString)
         {
-            return castIntToString(in, inLLVMType.getIntOrFloatBitWidth(), inType.cast<mlir::IntegerType>().isSignedInteger());
+            return castIntToString(in, inLLVMType.getIntOrFloatBitWidth(), inType.isSignedInteger());
         }
 
         if ((inLLVMType.isF16() || inLLVMType.isF32() || inLLVMType.isF64() || inLLVMType.isF128()) && isResString)
@@ -120,7 +122,19 @@ class CastLogicHelper
             return castF64ToString(in);
         }
 
-        if (inType.isIntOrIndex() && resType.isSignedInteger() && resType.getIntOrFloatBitWidth() > inType.getIntOrFloatBitWidth())
+        if (inType.isIndex())
+        {
+            if (resType.isSignedInteger())
+            {
+                return rewriter.create<mlir::index::CastSOp>(loc, resLLVMType, in);
+            }
+            else
+            {
+                return rewriter.create<mlir::index::CastUOp>(loc, resLLVMType, in);
+            }
+        }
+
+        if (inType.isSignedInteger() && resType.isSignedInteger() && resType.getIntOrFloatBitWidth() > inType.getIntOrFloatBitWidth())
         {
             return rewriter.create<LLVM::SExtOp>(loc, resLLVMType, in);
         }        
@@ -709,11 +723,9 @@ class CastLogicHelper
 
         LLVM_DEBUG(llvm::dbgs() << "invalid cast operator type 1: '" << inLLVMType << "', type 2: '" << resLLVMType << "'\n";);
 
-        // emitError(loc, "invalid cast from ") << inLLVMType << " to " << resLLVMType;
-
-        // return mlir::Value();
-        emitWarning(loc, "invalid cast from ") << inLLVMType << " to " << resLLVMType;
-        return rewriter.create<LLVM::UndefOp>(loc, resLLVMType);
+        emitError(loc, "invalid cast from ") << inLLVMType << " to " << resLLVMType;
+        //return rewriter.create<LLVM::UndefOp>(loc, resLLVMType);
+        return mlir::Value();
     }
 
     mlir::Value castTupleToTuple(mlir::Value in, ::llvm::ArrayRef<::mlir::typescript::FieldInfo> fields, mlir_ts::TupleType tupleTypeRes)
@@ -750,7 +762,6 @@ class CastLogicHelper
         };
 
         // map values
-        auto count = fields.size();
         auto dstIndex = -1;
         for (auto destField : tupleTypeRes.getFields())
         {
@@ -770,9 +781,8 @@ class CastLogicHelper
 
             auto found = false;
             auto anyFieldWithName = false;
-            for (auto index = 0; index < count; index++)
+            for (auto [index, srcField] : enumerate(fields))
             {
-                auto srcField = fields[index];
                 if (!srcField.id)
                 {
                     continue;

tsc/include/TypeScript/LowerToLLVM/LLVMDebugInfo.h

@@ -232,11 +232,8 @@ class LLVMDebugInfoHelper
         CompositeSizesTrack sizesTrack(llvmtch);
 
         llvm::SmallVector<LLVM::DINodeAttr> elements;
-        auto index = -1;
-        for (auto llvmElementType : structType.getBody())
+        for (auto [index, llvmElementType] : enumerate(structType.getBody()))
         {
-            index++;
-
             sizesTrack.nextElementType(llvmElementType);
 
             // name

tsc/include/TypeScript/LowerToLLVM/LLVMRTTIHelperVCWin32.h

@@ -406,10 +406,9 @@ class LLVMRTTIHelperVCWin32
             // make array
             mlir::Value arrayVal = rewriter.create<LLVM::UndefOp>(loc, th.getArrayType(th.getI32Type(), arraySize));
 
-            auto index = 0;
-            for (auto value : values)
+            for (auto [index, value] : enumerate(values))
             {
-                ch.setStructValue(loc, arrayVal, value, index++);
+                ch.setStructValue(loc, arrayVal, value, index);
             }
 
             // [size, {values...}]

tsc/include/TypeScript/LowerToLLVM/TypeConverterHelper.h

@@ -8,6 +8,7 @@
 #include "TypeScript/TypeScriptOps.h"
 
 #include "mlir/Transforms/DialectConversion.h"
+#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 
 using namespace mlir;
 namespace mlir_ts = mlir::typescript;
@@ -46,6 +47,11 @@ class TypeConverterHelper
 
         llvm_unreachable("not implemented");
     }
+
+    int getIndexTypeBitwidth()
+    {
+        return (*(mlir::LLVMTypeConverter *)&typeConverter).getIndexTypeBitwidth();
+    }
 };
 } // namespace typescript
 

tsc/include/TypeScript/LowerToLLVM/TypeOfOpHelper.h

@@ -52,7 +52,7 @@ class TypeOfOpHelper
 
         if (type.isIndex())
         {
-            auto typeOfValue = strValue(loc, "ptrint");
+            auto typeOfValue = strValue(loc, "index");
             return typeOfValue;
         }
 
@@ -81,6 +81,12 @@ class TypeOfOpHelper
             return typeOfValue;
         }
 
+        if (type.isa<mlir_ts::CharType>())
+        {
+            auto typeOfValue = strValue(loc, "char");
+            return typeOfValue;
+        }
+
         if (type.isa<mlir_ts::ArrayType>())
         {
             auto typeOfValue = strValue(loc, "array");

tsc/include/TypeScript/MLIRLogic/MLIRCodeLogic.h

@@ -26,13 +26,14 @@ namespace typescript
 class MLIRCodeLogic
 {
     mlir::MLIRContext *context;
+    mlir::OpBuilder builder;
 
   public:
-    MLIRCodeLogic(mlir::MLIRContext *context) : context(context)
+    MLIRCodeLogic(mlir::MLIRContext *context) : context(context), builder(context)
     {
     }
 
-    MLIRCodeLogic(mlir::OpBuilder builder) : context(builder.getContext())
+    MLIRCodeLogic(mlir::OpBuilder builder) : context(builder.getContext()), builder(builder)
     {
     }
 
@@ -54,14 +55,36 @@ class MLIRCodeLogic
         return mlir::Attribute();
     }
 
-    mlir::Value GetReferenceOfLoadOp(mlir::Value value)
+    mlir::Value GetReferenceOfLoadOp(mlir::Value object)
     {
-        // TODO: sync with Common Logic
-        if (auto loadOp = dyn_cast<mlir_ts::LoadOp>(value.getDefiningOp()))
+        if (auto loadOp = object.getDefiningOp<mlir_ts::LoadOp>())
         {
-            // this LoadOp will be removed later as unused
-            auto refValue = loadOp.getReference();
-            return refValue;
+            // get PropertyRef out of extractPropertyOp
+            return loadOp.getReference();
+        }        
+
+        if (auto valueOp = object.getDefiningOp<mlir_ts::ValueOp>())
+        {
+            if (auto nestedRef = GetReferenceOfLoadOp(valueOp.getIn()))
+            {
+                return builder.create<mlir_ts::PropertyRefOp>(
+                    object.getLoc(), 
+                    mlir_ts::RefType::get(valueOp.getType()), 
+                    nestedRef, 
+                    OPTIONAL_VALUE_INDEX);
+            }
+        }
+
+        if (auto extractPropertyOp = object.getDefiningOp<mlir_ts::ExtractPropertyOp>())
+        {
+            if (auto nestedRef = GetReferenceOfLoadOp(extractPropertyOp.getObject()))
+            {
+                return builder.create<mlir_ts::PropertyRefOp>(
+                    object.getLoc(), 
+                    mlir_ts::RefType::get(extractPropertyOp.getType()), 
+                    nestedRef, 
+                    extractPropertyOp.getPosition().front());
+            }
         }
 
         return mlir::Value();
@@ -232,7 +255,7 @@ class MLIRCustomMethods
         return m[functionName.str()];    
     }   
 
-    ValueOrLogicalResult callMethod(StringRef functionName, ArrayRef<mlir::Value> operands, std::function<ValueOrLogicalResult(mlir::Location, mlir::Type, mlir::Value, const GenContext &)> castFn, const GenContext &genContext)
+    ValueOrLogicalResult callMethod(StringRef functionName, mlir::SmallVector<mlir::Type> typeArgs, ArrayRef<mlir::Value> operands, std::function<ValueOrLogicalResult(mlir::Location, mlir::Type, mlir::Value, const GenContext &)> castFn, const GenContext &genContext)
     {
         if (functionName == "print")
         {
@@ -264,7 +287,7 @@ class MLIRCustomMethods
         }
         else if (functionName == "sizeof")
         {
-            return mlirGenSizeOf(location, operands);
+            return mlirGenSizeOf(location, typeArgs, operands);
         }
         else if (functionName == "__array_push")
         {
@@ -326,29 +349,8 @@ class MLIRCustomMethods
         {
             if (!oper.getType().isa<mlir_ts::StringType>())
             {
-                if (oper.getType().isa<mlir_ts::OptionalType>())
-                {
-                    auto hasValue = builder.create<mlir_ts::HasValueOp>(location, mlir_ts::BooleanType::get(builder.getContext()), oper);
-                    MLIRCodeLogicHelper mclh(builder, location);
-
-                    auto strType = mlir_ts::StringType::get(builder.getContext());
-                    auto optValue = mclh.conditionalExpression(
-                        strType, hasValue,
-                        [&](mlir::OpBuilder &builder, mlir::Location location) {
-                            return builder.create<mlir_ts::CastOp>(location, strType, oper);
-                        },
-                        [&](mlir::OpBuilder &builder, mlir::Location location) {
-                            return builder.create<mlir_ts::ConstantOp>(
-                                location, strType, builder.getStringAttr(UNDEFINED_NAME));
-                        });
-
-                    vals.push_back(optValue);
-                }
-                else
-                {
-                    auto strCast = castFn(location, mlir_ts::StringType::get(builder.getContext()), oper, genContext);
-                    vals.push_back(strCast);
-                }
+                auto strCast = castFn(location, mlir_ts::StringType::get(builder.getContext()), oper, genContext);
+                vals.push_back(strCast);
             }
             else
             {
@@ -491,12 +493,19 @@ class MLIRCustomMethods
         return isNaNOp;
     }
 
-    mlir::Value mlirGenSizeOf(const mlir::Location &location, ArrayRef<mlir::Value> operands)
+    mlir::Value mlirGenSizeOf(const mlir::Location &location, mlir::SmallVector<mlir::Type> typeArgs, ArrayRef<mlir::Value> operands)
     {
-        auto sizeOfValue = builder.create<mlir_ts::SizeOfOp>(location, builder.getIndexType(),
-                                                             mlir::TypeAttr::get(operands.front().getType()));
+        if (typeArgs.size() > 0)
+        {
+            return builder.create<mlir_ts::SizeOfOp>(location, builder.getIndexType(), mlir::TypeAttr::get(typeArgs.front()));
+        }
 
-        return sizeOfValue;
+        if (operands.size() > 0)
+        {
+            return builder.create<mlir_ts::SizeOfOp>(location, builder.getIndexType(), mlir::TypeAttr::get(operands.front().getType()));
+        }
+
+        return mlir::Value();
     }
 
     ValueOrLogicalResult mlirGenArrayPush(const mlir::Location &location, mlir::Value thisValue, ArrayRef<mlir::Value> values)

tsc/include/TypeScript/MLIRLogic/MLIRRTTIHelperVCLinux.h

@@ -91,19 +91,23 @@ class MLIRRTTIHelperVCLinux
     {
         auto first = true;
         auto countM1 = names.size() - 1;
-        auto index = 0;
-        for (auto name : names)
+        for (auto [index, name] : enumerate(names))
         {
             if (first)
             {
                 types.push_back({name.str(), TypeInfo::Pointer_TypeInfo, 1});
             }
 
-            types.push_back({name.str(), index < countM1 ? TypeInfo::SingleInheritance_ClassTypeInfo : TypeInfo::ClassTypeInfo,
-                             index < countM1 ? index + 2 : -1});
+            if (index < countM1)
+            {
+                types.push_back({ name.str(), TypeInfo::SingleInheritance_ClassTypeInfo, (int)index + 2 });
+            }
+            else
+            {
+                types.push_back({ name.str(), TypeInfo::ClassTypeInfo, -1 });
+            }
 
             first = false;
-            index++;
         }
     }