Fix __init() functions that returns an existing value (#3866)

Fixes the issue #3671

* The __init constructors are not expected to return a value like other member
  functions, but must construct a new value and return the struct type or none.

* This patch enables this behavior in the IR lowering without complaining about
  illegal situations where the user returns an invalid type or none at all.
   Translate    ordinary struct `return ...;` to `this = ...; return this;`
   Translate NonCopyableType struct `return ...;` to `return this;`

* This patch also fixes the issue with type checking when __init()
  returns a void that mismatches the base type of the struct/ class
   Translate    ordinary struct `return;` to `return this;`
   Translate NonCopyableType struct `return;` to `return;`

* Add end-to-end test and compile only tests to check the above behavior.

2 files changed, 39 insertions, 3 deletions

diff --git a/source/slang/slang-check-stmt.cpp b/source/slang/slang-check-stmt.cpp
index 729b24d35..f7b085579 100644
--- a/source/slang/slang-check-stmt.cpp
+++ b/source/slang/slang-check-stmt.cpp
@@ -392,7 +392,7 @@ namespace Slang
         auto function = getParentFunc();
         if (!stmt->expression)
         {
-            if (function && !function->returnType.equals(m_astBuilder->getVoidType()))
+            if (function && !function->returnType.equals(m_astBuilder->getVoidType()) && !as<ConstructorDecl>(function))
             {
                 getSink()->diagnose(stmt, Diagnostics::returnNeedsExpression);
             }
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
index 6a6ca7c64..3f776c1a1 100644
--- a/source/slang/slang-lower-to-ir.cpp
+++ b/source/slang/slang-lower-to-ir.cpp
@@ -586,6 +586,10 @@ struct IRGenContext
     // (For use by functions that returns non-copyable types)
     LoweredValInfo returnDestination;
 
+    // A reference to the Function decl to identify the parent function
+    // that contains the Inst.
+    FunctionDeclBase* funcDecl;
+
     bool includeDebugInfo = false;
 
     explicit IRGenContext(SharedIRGenContext* inShared, ASTBuilder* inAstBuilder)
@@ -6012,12 +6016,15 @@ struct StmtLoweringVisitor : StmtVisitor<StmtLoweringVisitor>
     {
         startBlockIfNeeded(stmt);
 
+        // Check if this return is within a constructor.
+        auto constructorDecl = as<ConstructorDecl>(context->funcDecl);
+
         // A `return` statement turns into a `return` instruction,
         // but we have two kinds of `return`: one for returning
         // a (non-`void`) value, and one for returning "no value"
         // (which effectively returns a value of type `void`).
         //
-        if( auto expr = stmt->expression )
+        if (auto expr = stmt->expression)
         {
             if (context->returnDestination.flavor != LoweredValInfo::Flavor::None)
             {
@@ -6027,6 +6034,16 @@ struct StmtLoweringVisitor : StmtVisitor<StmtLoweringVisitor>
                 return;
             }
 
+            if (constructorDecl)
+            {
+                // If this function is a constructor, but returns a value, rewrite it as
+                // this = val;
+                // return this;
+                lowerRValueExprWithDestination(context, context->thisVal, expr);
+                getBuilder()->emitReturn(getSimpleVal(context, context->thisVal));
+                return;
+            }
+
             // If the AST `return` statement had an expression, then we
             // need to lower it to the IR at this point, both to
             // compute its value and (in case we are returning a
@@ -6061,6 +6078,24 @@ struct StmtLoweringVisitor : StmtVisitor<StmtLoweringVisitor>
             // with no value, which can only occur in a function with
             // a `void` result type.
             //
+            if (constructorDecl)
+            {
+                // If this `return` is within a NonCopyableType or an ordinary constructor,
+                // then we must either simply return or `return` the instance respectively.
+                if (context->returnDestination.flavor != LoweredValInfo::Flavor::None)
+                {
+                    // If we have a NonCopyableType constructor of the form
+                    //   void ctor(inout this) { return; }
+                    getBuilder()->emitReturn();
+                }
+                else
+                {
+                    // If we have an ordinary constructor of the form
+                    //   Type ctor() { return; }
+                    getBuilder()->emitReturn(getSimpleVal(context, context->thisVal));
+                }
+                return;
+            }
             getBuilder()->emitReturn();
         }
     }
@@ -9298,7 +9333,8 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
     {
 
         IRGeneric* outerGeneric = nullptr;
-        
+        subContext->funcDecl = decl;
+
         if (auto derivativeRequirement = as<DerivativeRequirementDecl>(decl))
             outerGeneric = emitOuterGenerics(subContext, derivativeRequirement->originalRequirementDecl, derivativeRequirement->originalRequirementDecl);
         else