added support for native variadic arguments and added size validation for classes (#117)

* adding variadic func call

* implementted native varargs

* added test

* updated test

* adding convertf

* progress of adding convertf

* added converf

* using convertf

* added validation for params count for non-varargs calls

* added support for adding obj files

* added public property to manage removal of unused symbols

* added index support

* progress of fixes

* progress

* progress of implementing fixes and size field

* refactoring sizeof

* fixes to compare

* added size field to ensure integrity

* fixes to  class size field

* build scripts update

Author: ASDAlexander77

tag.bat

@@ -1,2 +1,2 @@
-git tag -a v0.0-pre-alpha50 -m "pre alpha v0.0-50"
+git tag -a v0.0-pre-alpha51 -m "pre alpha v0.0-51"
 git push origin --tags

tag_del.bat

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

tsc/include/TypeScript/DOM.h

@@ -208,12 +208,7 @@ class FunctionPrototypeDOM
 
     bool isMultiArgs()
     {
-        if (params.size() == 0)
-        {
-            return false;
-        }
-
-        return params.back()->getIsMultiArgsParam();
+        return params.size() > 0 && params.back()->getIsMultiArgsParam();
     }
 
     const mlir_ts::FunctionType &getFuncType() const

tsc/include/TypeScript/Defines.h

@@ -19,6 +19,7 @@
 #define CONSTRUCTOR_TEMPVAR_NAME ".ctor"
 #define VTABLE_NAME ".vtbl"
 #define RTTI_NAME ".rtti"
+#define SIZE_NAME ".size"
 #define INSTANCEOF_NAME ".instanceOf"
 #define INSTANCEOF_PARAM_NAME "rttiParam"
 #define MAIN_ENTRY_NAME "main"

tsc/include/TypeScript/LowerToLLVM/CodeLogicHelper.h

@@ -94,7 +94,7 @@ class CodeLogicHelper
 
     mlir::Value createIndexConstantOf(mlir::Type llvmIndexType, int64_t value)
     {
-        return rewriter.create<LLVM::ConstantOp>(loc, llvmIndexType, rewriter.getIntegerAttr(llvmIndexType, value));
+        return rewriter.create<LLVM::ConstantOp>(loc, llvmIndexType, rewriter.getIndexAttr(value));
     }
 
     mlir::Value createStructIndexConstantOf(int32_t value)

tsc/include/TypeScript/LowerToLLVM/ConvertLogic.h

@@ -29,14 +29,10 @@ class ConvertLogic
     CodeLogicHelper clh;
     Location loc;
 
-  protected:
-    mlir::Type typeOfValueType;
-
   public:
     ConvertLogic(Operation *op, PatternRewriter &rewriter, TypeConverterHelper &tch, Location loc, CompileOptions &compileOptions)
         : op(op), rewriter(rewriter), tch(tch), th(rewriter), ch(op, rewriter, &tch.typeConverter, compileOptions), clh(op, rewriter), loc(loc)
     {
-        typeOfValueType = th.getI8PtrType();
     }
 
     mlir::Value itoa(mlir::Value value)
@@ -92,17 +88,8 @@ class ConvertLogic
     {
         auto i8PtrTy = th.getI8PtrType();
 
-#ifdef WIN32
-        auto sprintfFuncOp = ch.getOrInsertFunction(
-            "sprintf_s", th.getFunctionType(rewriter.getI32Type(), {th.getI8PtrType(), rewriter.getI32Type(), th.getI8PtrType()}, true));
-#else
-        auto sprintfFuncOp = ch.getOrInsertFunction(
-            "snprintf", th.getFunctionType(rewriter.getI32Type(), {th.getI8PtrType(), rewriter.getI32Type(), th.getI8PtrType()}, true));
-#endif
-
-        auto bufferSizeValue = clh.createI32ConstantOf(buffSize);
-        // auto newStringValue = rewriter.create<LLVM::AllocaOp>(loc, i8PtrTy, bufferSizeValue, true);
-        auto newStringValue = ch.MemoryAllocBitcast(i8PtrTy, bufferSizeValue, MemoryAllocSet::Atomic);
+        auto llvmIndexType = tch.convertType(th.getIndexType());
+        auto bufferSizeValue = clh.createIndexConstantOf(llvmIndexType, buffSize);
 
         auto opHash = std::hash<std::string>{}(format);
 
@@ -111,11 +98,8 @@ class ConvertLogic
 
         auto formatSpecifierCst = ch.getOrCreateGlobalString(formatVarName.str(), format);
 
-        mlir::Value valueAsLLVMType = rewriter.create<mlir_ts::DialectCastOp>(loc, tch.convertType(value.getType()), value);
-
-        rewriter.create<LLVM::CallOp>(loc, sprintfFuncOp, ValueRange{newStringValue, bufferSizeValue, formatSpecifierCst, valueAsLLVMType});
-
-        return newStringValue;
+        auto newVal = rewriter.create<mlir_ts::ConvertFOp>(loc, th.getStringType(), bufferSizeValue, formatSpecifierCst, ValueRange{value});
+        return newVal;
     }
 
     mlir::Value sprintfOfF64(mlir::Value value)

tsc/include/TypeScript/MLIRLogic/MLIRCodeLogic.h

@@ -219,15 +219,15 @@ class MLIRCustomMethods
     static bool isInternalFunctionNameBuiltin (StringRef functionName)
     {
         static std::map<std::string, bool> m { 
-            {"print", true}, {"assert", true}, {"parseInt", true}, {"parseFloat", true}, {"isNaN", true}, {"sizeof", true}, {GENERATOR_SWITCHSTATE, true}, 
+            {"print", true}, {"convertf", true}, {"assert", true}, {"parseInt", true}, {"parseFloat", true}, {"isNaN", true}, {"sizeof", true}, {GENERATOR_SWITCHSTATE, true}, 
             {"LoadLibraryPermanently", true}, { "SearchForAddressOfSymbol", true }, { "LoadReference", true }, { "ReferenceOf", true }};
         return m[functionName.str()];    
     }    
 
     static bool isInternalFunctionNameNoBuiltin (StringRef functionName)
     {
         static std::map<std::string, bool> m { 
-            {"print", true}, {"assert", true}, {"sizeof", true}, {GENERATOR_SWITCHSTATE, true}, 
+            {"print", true}, {"convertf", true}, {"assert", true}, {"sizeof", true}, {GENERATOR_SWITCHSTATE, true}, 
             {"LoadLibraryPermanently", true}, { "SearchForAddressOfSymbol", true }, { "LoadReference", true }, { "ReferenceOf", true }};
         return m[functionName.str()];    
     }   
@@ -239,6 +239,11 @@ class MLIRCustomMethods
             // print - internal command;
             return mlirGenPrint(location, operands, castFn, genContext);
         }
+        else if (functionName == "convertf")
+        {
+            // print - internal command;
+            return mlirGenConvertF(location, operands, castFn, genContext);
+        }
         else if (functionName == "assert")
         {
             // assert - internal command;
@@ -356,6 +361,39 @@ class MLIRCustomMethods
         return mlir::success();
     }
 
+    ValueOrLogicalResult mlirGenConvertF(const mlir::Location &location, ArrayRef<mlir::Value> operands, std::function<ValueOrLogicalResult(mlir::Location, mlir::Type, mlir::Value, const GenContext &)> castFn, const GenContext &genContext)
+    {
+        mlir::Value bufferSize;
+        mlir::Value format;
+
+        if (operands.size() < 3) {
+            return mlir::failure();
+        }
+
+        bufferSize = operands[0];
+        if (!bufferSize.getType().isa<mlir::IndexType>())
+        {
+            bufferSize = castFn(location, mlir::IndexType::get(builder.getContext()), bufferSize, genContext);
+        }
+
+        auto stringType = mlir_ts::StringType::get(builder.getContext());
+        format = operands[1];
+        if (!format.getType().isa<mlir_ts::StringType>())
+        {
+            format = castFn(location, stringType, format, genContext);
+        }
+
+        SmallVector<mlir::Value> vals;
+        for (auto &oper : operands.take_back(operands.size() - 2))
+        {
+            vals.push_back(oper);
+        }
+
+        auto convertFOp = builder.create<mlir_ts::ConvertFOp>(location, stringType, bufferSize, format, vals);
+
+        return V(convertFOp);
+    }
+
     mlir::LogicalResult mlirGenAssert(const mlir::Location &location, ArrayRef<mlir::Value> operands)
     {
         if (operands.size() == 0)

tsc/include/TypeScript/MLIRLogic/MLIRGenStore.h

@@ -56,21 +56,33 @@ enum class VariableScope
     Global
 };
 
+enum class Select: int
+{
+    NotSet = -1, 
+    Any = 0, 	        //The linker may choose any COMDAT.
+    ExactMatch = 1,     //The data referenced by the COMDAT must be the same.
+    Largest = 2, 	    //The linker will choose the largest COMDAT.
+    NoDeduplicate = 3,  //No deduplication is performed.
+    SameSize = 4, 	    //The data referenced by the COMDAT must be the same size.
+};
+
 struct VariableClass
 {
-    VariableClass() : type{VariableType::Const}, isExport{false}, isImport{false}, isUsing{false}, isAppendingLinkage{false}
+    VariableClass() : type{VariableType::Const}, isExport{false}, isImport{false}, isPublic{false}, isUsing{false}, isAppendingLinkage{false}, comdat{Select::NotSet}
     {
     }
 
-    VariableClass(VariableType type_) : type{type_}, isExport{false}, isImport{false}, isUsing{false}, isAppendingLinkage{false}
+    VariableClass(VariableType type_) : type{type_}, isExport{false}, isImport{false}, isPublic{false}, isUsing{false}, isAppendingLinkage{false}, comdat{Select::NotSet}
     {
     }
 
     VariableType type;
     bool isExport;
     bool isImport;
+    bool isPublic;
     bool isUsing;
     bool isAppendingLinkage;
+    Select comdat;
 
     inline VariableClass& operator=(VariableType type_) { type = type_; return *this; }
 
@@ -462,14 +474,16 @@ struct ClassInfo
     bool isAbstract;
     bool isExport;
     bool isImport;
+    bool isPublic;
     bool isDynamicImport;
     bool hasRTTI;
     ProcessingStages processingAtEvaluation;
     ProcessingStages processing;
 
     ClassInfo()
         : isDeclaration(false), hasNew(false), hasConstructor(false), hasInitializers(false), hasStaticConstructor(false),
-          hasStaticInitializers(false), hasVirtualTable(false), isAbstract(false), isExport(false), isImport(false), isDynamicImport(false), hasRTTI(false),
+          hasStaticInitializers(false), hasVirtualTable(false), isAbstract(false), isExport(false), isImport(false), 
+          isPublic(false), isDynamicImport(false), hasRTTI(false),
           processingAtEvaluation(ProcessingStages::NotSet), processing(ProcessingStages::NotSet)
     {
     }

tsc/include/TypeScript/TypeScriptOps.td

@@ -365,6 +365,16 @@ def TypeScript_PrintOp : TypeScript_Op<"Print"> {
   let assemblyFormat = "`(` $inputs `)` attr-dict `:` type($inputs) ";  
 }
 
+def TypeScript_ConvertFOp : TypeScript_Op<"ConvertF"> {
+  let summary = "format convert operation";
+  let description = [{
+    The "convertf" builtin operation to convert values into string with format.
+  }];
+
+  let arguments = (ins Index:$bufferSize, TypeScript_String:$format, Variadic<AnyType>:$inputs);
+  let results = (outs TypeScript_String:$result);
+}
+
 def TypeScript_AssertOp : TypeScript_Op<"Assert"> {
   let summary = "Assert operation";
   let description = [{
@@ -580,9 +590,7 @@ def TypeScript_DeleteOp : TypeScript_Op<"Delete"> {
   let assemblyFormat = "`(` $reference `)` attr-dict `:` type($reference)";
 }
 
-def TypeScript_CallOp : TypeScript_Op<"Call",
-    [CallOpInterface,
-     DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
+def TypeScript_CallOp : TypeScript_Op<"Call", [CallOpInterface, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
   let summary = "call operation";
   let description = [{
     The `call` operation represents a direct call to a function that is within
@@ -596,7 +604,7 @@ def TypeScript_CallOp : TypeScript_Op<"Call",
   }];
 
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$callOperands);
-  let results = (outs Variadic<AnyType>);
+  let results = (outs Variadic<AnyType>:$results);
 
   let builders = [
     OpBuilder<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$callOperands), [{
@@ -644,9 +652,6 @@ def TypeScript_CallOp : TypeScript_Op<"Call",
 def TypeScript_CallIndirectOp : TypeScript_Op<"CallIndirect", [
       CallOpInterface,
       DeclareOpInterfaceMethods<SymbolUserOpInterface>,
-      TypesMatchWith<"callee input types match argument types",
-                     "callee", "callOperands",
-                     "($_self.isa<HybridFunctionType>() ? $_self.cast<HybridFunctionType>().getInputs() : $_self.cast<FunctionType>().getInputs())">,
       TypesMatchWith<"callee result types match result types",
                      "callee", "results",
                      "($_self.isa<HybridFunctionType>() ? $_self.cast<HybridFunctionType>().getResults() : $_self.cast<FunctionType>().getResults())">
@@ -699,7 +704,7 @@ def TypeScript_CallIndirectOp : TypeScript_Op<"CallIndirect", [
 
   let hasCanonicalizer = 1;
 
-  let assemblyFormat = "$callee `(` $callOperands `)` attr-dict `:` type($callee)";
+  let assemblyFormat = "$callee `[` type($callee) `]` `(` $callOperands `)` attr-dict `:` functional-type($callOperands, results)";
 }
 
 def TypeScript_InvokeOp : TypeScript_Op<"Invoke", [

tsc/lib/TypeScript/LowerToAffineLoops.cpp

@@ -1868,7 +1868,7 @@ void AddTsAffineLegalOps(ConversionTarget &target)
         mlir_ts::ArithmeticUnaryOp, mlir_ts::AssertOp, mlir_ts::CastOp, mlir_ts::ConstantOp, mlir_ts::ElementRefOp,
         mlir_ts::PointerOffsetRefOp, mlir_ts::FuncOp, mlir_ts::GlobalOp, mlir_ts::GlobalResultOp, mlir_ts::HasValueOp,
         mlir_ts::ValueOp, mlir_ts::ValueOrDefaultOp, mlir_ts::NullOp, mlir_ts::ParseFloatOp, mlir_ts::ParseIntOp, mlir_ts::IsNaNOp,
-        mlir_ts::PrintOp, mlir_ts::SizeOfOp, mlir_ts::StoreOp, mlir_ts::SymbolRefOp, mlir_ts::LengthOfOp, mlir_ts::SetLengthOfOp,
+        mlir_ts::PrintOp, mlir_ts::ConvertFOp, mlir_ts::SizeOfOp, mlir_ts::StoreOp, mlir_ts::SymbolRefOp, mlir_ts::LengthOfOp, mlir_ts::SetLengthOfOp,
         mlir_ts::StringLengthOp, mlir_ts::StringConcatOp, mlir_ts::StringCompareOp, mlir_ts::LoadOp, mlir_ts::NewOp,
         mlir_ts::CreateTupleOp, mlir_ts::DeconstructTupleOp, mlir_ts::CreateArrayOp, mlir_ts::NewEmptyArrayOp,
         mlir_ts::NewArrayOp, mlir_ts::DeleteOp, mlir_ts::PropertyRefOp, mlir_ts::InsertPropertyOp,