WIP: attempt to extract RawRepresentable

Author: ApolloZhu

include/swift/AST/ConstTypeInfo.h

@@ -37,7 +37,8 @@ class CompileTimeValue {
     Tuple,
     Enum,
     Type,
-    Runtime
+    Runtime,
+    RawRepresentable
   };
 
   ValueKind getKind() const { return Kind; }
@@ -66,6 +67,25 @@ class RawLiteralValue : public CompileTimeValue {
   std::string Value;
 };
 
+class RawRepresentableValue : public CompileTimeValue {
+public:
+  RawRepresentableValue(std::string Name,
+                        std::shared_ptr<CompileTimeValue> Value)
+      : CompileTimeValue(ValueKind::RawRepresentable), Name(Name),
+        Value(Value) {}
+
+  std::string getName() const { return Name; }
+  std::shared_ptr<CompileTimeValue> getValue() const { return Value; }
+
+  static bool classof(const CompileTimeValue *T) {
+    return T->getKind() == ValueKind::RawRepresentable;
+  }
+
+private:
+  std::string Name;
+  std::shared_ptr<CompileTimeValue> Value;
+};
+
 struct FunctionParameter {
   std::string Label;
   swift::Type Type;

lib/ConstExtract/ConstExtract.cpp

@@ -381,6 +381,31 @@ static std::shared_ptr<CompileTimeValue> extractCompileTimeValue(Expr *expr) {
       return extractCompileTimeValue(injectIntoOptionalExpr->getSubExpr());
     }
 
+    case ExprKind::MemberRef: {
+      auto memberRefExpr = cast<MemberRefExpr>(expr);
+      // somehow check raw representable
+      auto base = memberRefExpr->getBase();
+      if (base->getKind() == ExprKind::Type) {
+        auto type = cast<TypeExpr>(base)->getInstanceType();
+        // FIXME: ApolloZhu check type == expr->getType()
+        // FIXME: ApolloZhu need a better way of getDecl for all types
+        auto typeDecl = type->getAs<NominalType>()->getDecl();
+        for (auto &protocol : typeDecl->getAllProtocols()) {
+          if (protocol->getKnownProtocolKind() &&
+              *protocol->getKnownProtocolKind() ==
+                  KnownProtocolKind::RawRepresentable) {
+            auto decl = memberRefExpr->getMember().getDecl();
+            // FIXME: ApolloZhu check it's actually VarDecl
+            auto caseName = decl->getName().getBaseIdentifier().str().str();
+            auto init = cast<VarDecl>(decl)->getParentInitializer();
+            return std::make_shared<RawRepresentableValue>(
+                caseName, extractCompileTimeValue(init));
+          }
+        }
+      }
+      break;
+    }
+
     default: {
       break;
     }
@@ -587,6 +612,16 @@ void writeValue(llvm::json::OStream &JSON,
     break;
   }
 
+  case CompileTimeValue::ValueKind::RawRepresentable: {
+    auto rawRepresentable = cast<RawRepresentableValue>(value);
+    JSON.attribute("valueKind", "RawRepresentable");
+    JSON.attributeObject("value", [&]() {
+      JSON.attribute("name", rawRepresentable->getName());
+      writeValue(JSON, rawRepresentable->getValue());
+    });
+    break;
+  }
+
   case CompileTimeValue::ValueKind::InitCall: {
     auto initCallValue = cast<InitCallValue>(value);