Principal Types: Add signature interop (#7777)

Author: kripken

src/ir/principal-type.cpp

@@ -1050,7 +1050,23 @@ bool PrincipalType::compose(const PrincipalType& next) {
 }
 
 std::optional<Signature> PrincipalType::getSignature() const {
-  WASM_UNREACHABLE("TODO");
+  std::vector<Type> sigParams, sigResults;
+  for (auto it = rparams.rbegin(); it != rparams.rend(); ++it) {
+    auto item = *it;
+    if (auto* type = std::get_if<Type>(&item)) {
+      sigParams.push_back(*type);
+    } else {
+      return {};
+    }
+  }
+  for (auto& result : results) {
+    if (auto* type = std::get_if<Type>(&result)) {
+      sigResults.push_back(*type);
+    } else {
+      return {};
+    }
+  }
+  return Signature(sigParams, sigResults);
 }
 
 std::ostream& operator<<(std::ostream& o, const PrincipalType& type) {

src/ir/principal-type.h

@@ -113,6 +113,16 @@ struct PrincipalType {
     std::reverse(rparams.begin(), rparams.end());
   }
 
+  PrincipalType(Signature sig) {
+    for (auto param : sig.params) {
+      rparams.push_back(param);
+    }
+    std::reverse(rparams.begin(), rparams.end());
+    for (auto result : sig.results) {
+      results.push_back(result);
+    }
+  }
+
   // Update this type to be the composition of this and `next`.
   bool compose(const PrincipalType& next);
 

test/gtest/principal-type.cpp

@@ -610,3 +610,45 @@ TEST(PrincipalTypeTest, UnifyVariables) {
           ({refE0Foo, refE0Foo}, {refE0Foo}),
           ({}, {refFoo}));
 }
+
+// Signature interop
+
+// Test that round-tripping works of a signature to a principal type.
+static void testSignatureRoundTrip(const Signature& sig) {
+  SCOPED_TRACE("Testing signature: " + sig.toString());
+
+  PrincipalType pt(sig);
+  std::optional<Signature> maybeSig = pt.getSignature();
+  ASSERT_TRUE(maybeSig.has_value());
+  EXPECT_EQ(*maybeSig, sig);
+}
+
+TEST(PrincipalTypeTest, SignatureRoundTrip) {
+  testSignatureRoundTrip(Signature(Type::none, Type::none));
+  testSignatureRoundTrip(Signature({Type::i32, Type::f64}, Type::none));
+  testSignatureRoundTrip(Signature(Type::none, {Type::i64, Type::f32}));
+  testSignatureRoundTrip(
+    Signature({Type::i32, Type::f32}, {Type::i64, Type::f64}));
+}
+
+TEST(PrincipalTypeTest, GetSignatureFailure) {
+  // Failure due to a type variable (Index) in parameters or results.
+  {
+    PrincipalType pt({0u}, {});
+    EXPECT_FALSE(pt.getSignature().has_value());
+  }
+  {
+    PrincipalType pt({}, {0u});
+    EXPECT_FALSE(pt.getSignature().has_value());
+  }
+
+  // Failure due to a heap type variable (VarRef) in parameters or results.
+  {
+    PrincipalType pt({VarRef{NonNullable, {0u}}}, {});
+    EXPECT_FALSE(pt.getSignature().has_value());
+  }
+  {
+    PrincipalType pt({}, {VarRef{NonNullable, {0u}}});
+    EXPECT_FALSE(pt.getSignature().has_value());
+  }
+}