From cc98fd4606222ec1d18878d5e8278dc32910076b Mon Sep 17 00:00:00 2001
From: Tim Foley <tfoleyNV@users.noreply.github.com>
Date: Fri, 3 Nov 2017 12:25:46 -0700
Subject: Fix #248 (#249)

* Fix up test runner output for compute.

We want compute-based tests to produce a `.actual` file when compilation fails, so we can easily diagnose the issue. I thought I'd added this capability previous, but it seemst to not be present any more.

* Compute result types for constructor decls

Fixes #246

When the parser sees an `init()` declaration, it can't easily know what type is is supposed to return, so it leaves the type as NULL. This was causing some downstream crashes.

Rather than special-case every site that cares about the result type of a callable, we will instead ensure that we install an actual result type on an initializer/constructor as part of its semantic checking.
This code needs to handle both the case where the initializer is declared inside a type, as well as the case where it is declared inside an `extension`.
---
 source/slang/check.cpp | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

(limited to 'source/slang/check.cpp')

diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index 0c35c4bf4..3116bbbd2 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -3228,6 +3228,46 @@ namespace Slang
             decl->SetCheckState(DeclCheckState::Checked);
         }
 
+        // Figure out what type an initializer/constructor declaration
+        // is supposed to return. In most cases this is just the type
+        // declaration that its declaration is nested inside.
+        RefPtr<Type> findResultTypeForConstructorDecl(ConstructorDecl* decl)
+        {
+            // We want to look at the parent of the declaration,
+            // but if the declaration is generic, the parent will be
+            // the `GenericDecl` and we need to skip past that to
+            // the grandparent.
+            //
+            auto parent = decl->ParentDecl;
+            auto genericParent = dynamic_cast<GenericDecl*>(parent);
+            if (genericParent)
+            {
+                parent = genericParent->ParentDecl;
+            }
+
+            // Now look at the type of the parent (or grandparent).
+            if (auto aggTypeDecl = dynamic_cast<AggTypeDecl*>(parent))
+            {
+                // We are nested in an aggregate type declaration,
+                // so the result type of the initializer will just
+                // be the surrounding type.
+                return DeclRefType::Create(
+                    getSession(),
+                    makeDeclRef(aggTypeDecl));
+            }
+            else if (auto extDecl = dynamic_cast<ExtensionDecl*>(parent))
+            {
+                // We are nested inside an extension, so the result
+                // type needs to be the type being extended.
+                return extDecl->targetType.type;
+            }
+            else
+            {
+                getSink()->diagnose(decl, Diagnostics::initializerNotInsideType);
+                return nullptr;
+            }
+        }
+
         void visitConstructorDecl(ConstructorDecl* decl)
         {
             if (decl->IsChecked(DeclCheckState::Checked)) return;
@@ -3237,6 +3277,12 @@ namespace Slang
             {
                 paramDecl->type = CheckUsableType(paramDecl->type);
             }
+
+            // We need to compute the result tyep for this declaration,
+            // since it wasn't filled in for us.
+            decl->ReturnType.type = findResultTypeForConstructorDecl(decl);
+
+
             decl->SetCheckState(DeclCheckState::CheckedHeader);
 
             // TODO(tfoley): check body
-- 
cgit v1.2.3