Keep fixing test errors

1. When extension of a struct defines __init, we should not synthesize
   __init anymore.

2. For the synthesized __init signature, we correct the default value
   for the parameter. Figuring out what exactly is "default initialize
   type". If a type has a ctor can take 0 parameter, it's default
   initialize type.

source/slang/slang-ast-decl.h

@@ -170,6 +170,7 @@ SLANG_UNREFLECTED
     // We will use these auxiliary to help in synthesizing the member initialize constructor.
     Slang::HashSet<VarDeclBase*>            m_membersVisibleInCtor;
     Dictionary<int, ConstructorDecl*>       m_synthesizedCtorMap;
+    bool                                    m_hasExplicitCtorInExtension = false;
 };
 
 class ClassDecl : public AggTypeDecl

source/slang/slang-check-decl.cpp

@@ -2194,16 +2194,10 @@ namespace Slang
         return true;
     }
 
-    static Expr* constructDefaultInitExprForType(SemanticsVisitor* visitor, VarDeclBase* varDecl)
+    static Expr* constructDefaultConstructorForType(SemanticsVisitor* visitor, Type* type)
     {
-        if (!varDecl->type || !varDecl->type.type)
-            return nullptr;
-
-        if (!isDefaultInitializable(varDecl))
-            return nullptr;
-
         ConstructorDecl* defaultCtor = nullptr;
-        auto declRefType = as<DeclRefType>(varDecl->type.type);
+        auto declRefType = as<DeclRefType>(type);
         if (declRefType)
         {
             if (auto structDecl = as<StructDecl>(declRefType->getDeclRef().getDecl()))
@@ -2219,6 +2213,22 @@ namespace Slang
             invoke->functionExpr = visitor->ConstructDeclRefExpr(member, nullptr, defaultCtor->getName(), defaultCtor->loc, nullptr);
             return invoke;
         }
+
+        return nullptr;
+    }
+
+    static Expr* constructDefaultInitExprForType(SemanticsVisitor* visitor, VarDeclBase* varDecl)
+    {
+        if (!varDecl->type || !varDecl->type.type)
+            return nullptr;
+
+        if (!isDefaultInitializable(varDecl))
+            return nullptr;
+
+        if (auto defaultInitExpr = constructDefaultConstructorForType(visitor, varDecl->type.type))
+        {
+            return defaultInitExpr;
+        }
         else
         {
             auto* defaultCall = visitor->getASTBuilder()->create<DefaultConstructExpr>();
@@ -7241,6 +7251,10 @@ namespace Slang
 
         auto _hasExplicitCtor = [](StructDecl* structDecl) -> bool
         {
+            // First check if the extension of this struct defines an explicit constructor.
+            if (structDecl->m_hasExplicitCtorInExtension)
+                return true;
+
             for (auto ctor : structDecl->getMembersOfType<ConstructorDecl>())
             {
                 // constructor that is not synthesized must be user defined.
@@ -9232,6 +9246,15 @@ namespace Slang
 
             _validateCrossModuleInheritance(decl, inheritanceDecl);
         }
+
+        if(decl->getMembersOfType<ConstructorDecl>().getCount() > 0)
+        {
+            if (auto structDeclRef = isDeclRefTypeOf<StructDecl>(decl->targetType.type))
+            {
+                auto structDecl = structDeclRef.getDecl();
+                structDecl->m_hasExplicitCtorInExtension = true;
+            }
+        }
     }
 
     Type* SemanticsVisitor::calcThisType(DeclRef<Decl> declRef)
@@ -11347,9 +11370,9 @@ namespace Slang
 
     // If a struct's member has:
     // 1. an initialize expersion: Struct S {int a = 1;}; or
-    // 2. a default value: Struct T{}; Struct S {T t;}
-    //    Note, If a type is not default initializable, it doesn't have default value.
-    // it can be associated with default value expression in the constructor signature.
+    // 2. this member is a default initializable type.
+    // See https://github.com/shader-slang/slang/blob/master/docs/proposals/004-initialization.md#default-initializable-type
+    // for the definition of "Default Initializable type".
     // This function helps to check whether either of those 2 conditions are met and create
     // a default value for the parameter.
     // It's totally fine that there is no default value for the parameter, in this case, user
@@ -11364,7 +11387,13 @@ namespace Slang
 
         // For the 2nd condition, we need to check if the type is default initializable, if so,
         // we can use the default constructor.
-        return constructDefaultInitExprForType(visitor, varDecl);
+        if (!varDecl->type || !varDecl->type.type)
+            return nullptr;
+
+        if (!isDefaultInitializable(varDecl))
+            return nullptr;
+
+        return constructDefaultConstructorForType(visitor, varDecl->type.type);
     }
 
     void SemanticsDeclAttributesVisitor::_synthesizeCtorSignature(StructDecl* structDecl)

tests/diagnostics/mismatching-types.slang

@@ -62,6 +62,7 @@ void main(uint3 dispatchThreadID : SV_DispatchThreadID)
     // expected an expression of type 'GenericOuter<int>.NonGenericInner', got 'GenericOuter<float>.NonGenericInner'
     a.ng = b.ng;
     // expected an expression of type 'NonGenericOuter.GenericInner<int>', got 'int'
+    // explicit conversion from 'int' to 'GenericInner<int>' is possible
     c.i = 0;
     // expected an expression of type 'NonGenericOuter.GenericInner<int>', got 'NonGenericOuter.GenericInner<float>'
     c.i = c.f;

tests/diagnostics/mismatching-types.slang.expected

@@ -20,6 +20,7 @@ tests/diagnostics/mismatching-types.slang(63): error 30019: expected an expressi
 tests/diagnostics/mismatching-types.slang(65): error 30019: expected an expression of type 'GenericInner<int>', got 'int'
     c.i = 0;
           ^
+tests/diagnostics/mismatching-types.slang(65): note: explicit conversion from 'int' to 'GenericInner<int>' is possible
 tests/diagnostics/mismatching-types.slang(67): error 30019: expected an expression of type 'GenericInner<int>', got 'GenericInner<float>'
     c.i = c.f;
             ^
@@ -32,6 +33,7 @@ tests/diagnostics/mismatching-types.slang(80): error 30019: expected an expressi
                         ^~~
 tests/diagnostics/mismatching-types.slang(82): error 30019: expected an expression of type 'Texture2D<float>', got 'Texture1D<float>'
     Texture2D<float> t2 = tex;
+                          ^~~
 }
 standard output = {
 }