Bug fixes (#161)

* Refactor namespace resolution logic in MLIRGen to improve clarity and functionality

* Refactor function instantiation logic in MLIRGen to enhance clarity and prevent nested generics instantiation

* Simplify bound function creation by removing unnecessary opaque type casting

* Refactor MLIRGen to remove unnecessary reference type casting and improve type handling; add tests for nested function captures

* Enhance MLIR type handling with new toPrimitive methods; add tests for primitive operations

* update test

* Enhance MLIRGen to support primitive type casting in binary operations; improve class instance handling for union types

* refactoring

* refactoring binary ops

* Refactor MLIRGen to improve function processing and error handling; ensure consistent return types for lambdas

* Enhance MLIRGen to improve type casting checks; add validation for class and interface types during casting

* Refactor MLIRGen to enhance handling of 'this' context; improve type checks for class and storage types during method resolution

* Remove obsolete bug18 test and add new tests for class iterator with super calls

* Implement rollback for postponed error messages and enhance generic function instantiation for binary operations

* Add tests for logical assignment operators and their behavior with optional parameters

* Remove obsolete bug23 test and add new tests for logical assignment operators

* Enhance MLIRGen to support additional function types in type handling

Author: ASDAlexander77

docs/bugs/bug23.ts

@@ -1,13 +1,24 @@
 function render(screenWidth, screenHeight) {
     const getPoint = (x, y) => {
-        var recenterX = x =>(x - (screenWidth / 2.0)) / 2.0 / screenWidth;
-        var recenterY = y => - (y - (screenHeight / 2.0)) / 2.0 / screenHeight;
+        const recenterX = x => (x - (screenWidth / 2.0)) / 2.0 / screenWidth;
+        const recenterY = y => -(y - (screenHeight / 2.0)) / 2.0 / screenHeight;
         return recenterX(x) + recenterY(y);
     }
 
-    const v = getPoint(0, 0);
+    const v = getPoint(512, 384);
+    print(v);
+    assert(v === 0);
+
+    const v2 = getPoint(1024, 768);
+    print(v2);
+    assert(v2 === 0);
+
+    const v3 = getPoint(300, 200);
+    print(v3);
+    assert((v3 - 0.016276) < 0.0001);
+
 }
 
-render(8, 6);
+render(1024, 768);
 
 print('done');

docs/bugs/generic_in_generic.ts

@@ -1,2 +1,2 @@
-git tag -a v0.0-pre-alpha71 -m "pre alpha v0.0-71"
+git tag -a v0.0-pre-alpha72 -m "pre alpha v0.0-72"
 git push origin --tags

tag.bat

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

tag_del.bat

@@ -253,7 +253,7 @@ class MLIRCodeLogic
 
     mlir::Type CaptureTypeStorage(llvm::StringMap<ts::VariableDeclarationDOM::TypePtr> &capturedVars)
     {
-        SmallVector<mlir_ts::FieldInfo> fields;
+        SmallVector<mlir_ts::FieldInfo> fields; 
         for (auto &varInfo : capturedVars)
         {
             auto &value = varInfo.getValue();

tsc/include/TypeScript/MLIRLogic/MLIRCodeLogic.h

@@ -16,6 +16,21 @@ class MLIRTypeCore
 {  
 public:    
 
+    static bool canHaveToPrimitiveMethod(mlir::Type type)
+    {
+        return isa<mlir_ts::ClassType>(type) 
+                || isa<mlir_ts::InterfaceType>(type)
+                || isa<mlir_ts::ObjectType>(type)
+                || isa<mlir_ts::TupleType>(type)
+                || isa<mlir_ts::ConstTupleType>(type);
+    }
+
+    static bool shouldCastToNumber(mlir::Type type)
+    {
+        return isa<mlir::IntegerType>(type) 
+            || isa<mlir::FloatType>(type);
+    }
+
     static bool isNullableTypeNoUnion(mlir::Type typeIn)
     {
         if (isa<mlir_ts::NullType>(typeIn)