[NFC] Wean SILParser off of TypeLocs

It was just using them as a currency type because performTypeLocChecking accepted them as a parameter. Cleaning up performTypeLocChecking is something that needs to be done independently of this changeset, so for now just encapsulate the use of TypeLocs as much as possible and use TypeRepr instead.

Author: CodaFi

lib/SIL/Parser/ParseSIL.cpp

@@ -174,7 +174,7 @@ namespace {
     /// A callback to be invoked every time a type was deserialized.
     std::function<void(Type)> ParsedTypeCallback;
 
-    bool performTypeLocChecking(TypeLoc &T, bool IsSILType,
+    Type performTypeLocChecking(TypeRepr *TyR, bool IsSILType,
                                 GenericEnvironment *GenericEnv = nullptr);
 
     void convertRequirements(SILFunction *F, ArrayRef<RequirementRepr> From,
@@ -868,34 +868,32 @@ void SILParser::convertRequirements(SILFunction *F,
   IdentTypeReprLookup PerformLookup(P);
   // Use parser lexical scopes to resolve references
   // to the generic parameters.
-  auto ResolveToInterfaceType = [&](TypeLoc Ty) -> Type {
-    Ty.getTypeRepr()->walk(PerformLookup);
-    performTypeLocChecking(Ty, /* IsSIL */ false);
-    assert(Ty.getType());
-    return Ty.getType()->mapTypeOutOfContext();
+  auto ResolveToInterfaceType = [&](TypeRepr *Ty) -> Type {
+    Ty->walk(PerformLookup);
+    return performTypeLocChecking(Ty, /* IsSIL */ false)->mapTypeOutOfContext();
   };
 
   for (auto &Req : From) {
     if (Req.getKind() == RequirementReprKind::SameType) {
-      auto FirstType = ResolveToInterfaceType(Req.getFirstTypeLoc());
-      auto SecondType = ResolveToInterfaceType(Req.getSecondTypeLoc());
+      auto FirstType = ResolveToInterfaceType(Req.getFirstTypeRepr());
+      auto SecondType = ResolveToInterfaceType(Req.getSecondTypeRepr());
       Requirement ConvertedRequirement(RequirementKind::SameType, FirstType,
                                        SecondType);
       To.push_back(ConvertedRequirement);
       continue;
     }
 
     if (Req.getKind() == RequirementReprKind::TypeConstraint) {
-      auto Subject = ResolveToInterfaceType(Req.getSubjectLoc());
-      auto Constraint = ResolveToInterfaceType(Req.getConstraintLoc());
+      auto Subject = ResolveToInterfaceType(Req.getSubjectRepr());
+      auto Constraint = ResolveToInterfaceType(Req.getConstraintRepr());
       Requirement ConvertedRequirement(RequirementKind::Conformance, Subject,
                                        Constraint);
       To.push_back(ConvertedRequirement);
       continue;
     }
 
     if (Req.getKind() == RequirementReprKind::LayoutConstraint) {
-      auto Subject = ResolveToInterfaceType(Req.getSubjectLoc());
+      auto Subject = ResolveToInterfaceType(Req.getSubjectRepr());
       Requirement ConvertedRequirement(RequirementKind::Layout, Subject,
                                        Req.getLayoutConstraint());
       To.push_back(ConvertedRequirement);
@@ -1094,14 +1092,16 @@ static bool parseDeclSILOptional(bool *isTransparent,
   return false;
 }
 
-bool SILParser::performTypeLocChecking(TypeLoc &T, bool IsSILType,
+Type SILParser::performTypeLocChecking(TypeRepr *T, bool IsSILType,
                                        GenericEnvironment *GenericEnv) {
   if (GenericEnv == nullptr)
     GenericEnv = ContextGenericEnv;
 
-  return swift::performTypeLocChecking(P.Context, T,
+  TypeLoc loc(T);
+  (void) swift::performTypeLocChecking(P.Context, loc,
                                        /*isSILMode=*/true, IsSILType,
                                        GenericEnv, &P.SF);
+  return loc.getType();
 }
 
 /// Find the top-level ValueDecl or Module given a name.
@@ -1155,17 +1155,17 @@ static ValueDecl *lookupMember(Parser &P, Type Ty, DeclBaseName Name,
 bool SILParser::parseASTType(CanType &result, GenericEnvironment *env) {
   ParserResult<TypeRepr> parsedType = P.parseType();
   if (parsedType.isNull()) return true;
-  TypeLoc loc = parsedType.get();
-  if (performTypeLocChecking(loc, /*IsSILType=*/ false, env))
+  auto resolvedType = performTypeLocChecking(parsedType.get(), /*IsSILType=*/ false, env);
+  if (resolvedType->hasError())
     return true;
 
   if (env)
-    result = loc.getType()->mapTypeOutOfContext()->getCanonicalType();
+    result = resolvedType->mapTypeOutOfContext()->getCanonicalType();
   else
-    result = loc.getType()->getCanonicalType();
+    result = resolvedType->getCanonicalType();
 
   // Invoke the callback on the parsed type.
-  ParsedTypeCallback(loc.getType());
+  ParsedTypeCallback(resolvedType);
   return false;
 }
 
@@ -1244,16 +1244,16 @@ bool SILParser::parseSILType(SILType &Result,
       ParsedGenericEnv = env;
 
   // Apply attributes to the type.
-  TypeLoc Ty = P.applyAttributeToType(TyR.get(), attrs, specifier, specifierLoc);
-
-  if (performTypeLocChecking(Ty, /*IsSILType=*/true, OuterGenericEnv))
+  auto *attrRepr = P.applyAttributeToType(TyR.get(), attrs, specifier, specifierLoc);
+  auto Ty = performTypeLocChecking(attrRepr, /*IsSILType=*/true, OuterGenericEnv);
+  if (Ty->hasError())
     return true;
 
-  Result = SILType::getPrimitiveType(Ty.getType()->getCanonicalType(),
+  Result = SILType::getPrimitiveType(Ty->getCanonicalType(),
                                      category);
 
   // Invoke the callback on the parsed type.
-  ParsedTypeCallback(Ty.getType());
+  ParsedTypeCallback(Ty);
 
   return false;
 }
@@ -1644,34 +1644,34 @@ bool SILParser::parseSILBBArgsAtBranch(SmallVector<SILValue, 6> &Args,
 ///
 /// FIXME: This is a hack to work around the lack of a DeclContext for
 /// witness tables.
-static void bindProtocolSelfInTypeRepr(TypeLoc &TL, ProtocolDecl *proto) {
-  if (auto typeRepr = TL.getTypeRepr()) {
-    // AST walker to update 'Self' references.
-    class BindProtocolSelf : public ASTWalker {
-      ProtocolDecl *proto;
-      GenericTypeParamDecl *selfParam;
-      Identifier selfId;
-
-    public:
-      BindProtocolSelf(ProtocolDecl *proto)
-        : proto(proto),
-          selfParam(proto->getProtocolSelfType()->getDecl()),
-          selfId(proto->getASTContext().Id_Self) {
-      }
+static void bindProtocolSelfInTypeRepr(TypeRepr *typeRepr, ProtocolDecl *proto) {
+  assert(typeRepr);
 
-      virtual bool walkToTypeReprPre(TypeRepr *T) override {
-        if (auto ident = dyn_cast<IdentTypeRepr>(T)) {
-          auto firstComponent = ident->getComponentRange().front();
-          if (firstComponent->getNameRef().isSimpleName(selfId))
-            firstComponent->setValue(selfParam, proto);
-        }
+  // AST walker to update 'Self' references.
+  class BindProtocolSelf : public ASTWalker {
+    ProtocolDecl *proto;
+    GenericTypeParamDecl *selfParam;
+    Identifier selfId;
 
-        return true;
+  public:
+    BindProtocolSelf(ProtocolDecl *proto)
+      : proto(proto),
+        selfParam(proto->getProtocolSelfType()->getDecl()),
+        selfId(proto->getASTContext().Id_Self) {
+    }
+
+    virtual bool walkToTypeReprPre(TypeRepr *T) override {
+      if (auto ident = dyn_cast<IdentTypeRepr>(T)) {
+        auto firstComponent = ident->getComponentRange().front();
+        if (firstComponent->getNameRef().isSimpleName(selfId))
+          firstComponent->setValue(selfParam, proto);
       }
-    };
 
-    typeRepr->walk(BindProtocolSelf(proto));
-  }
+      return true;
+    }
+  };
+
+  typeRepr->walk(BindProtocolSelf(proto));
 }
 
 /// Parse the substitution list for an apply instruction or
@@ -1693,12 +1693,13 @@ bool SILParser::parseSubstitutions(SmallVectorImpl<ParsedSubstitution> &parsed,
     ParserResult<TypeRepr> TyR = P.parseType();
     if (TyR.isNull())
       return true;
-    TypeLoc Ty = TyR.get();
     if (defaultForProto)
-      bindProtocolSelfInTypeRepr(Ty, defaultForProto);
-    if (performTypeLocChecking(Ty, /*IsSILType=*/ false, GenericEnv))
+      bindProtocolSelfInTypeRepr(TyR.get(), defaultForProto);
+
+    auto Ty = performTypeLocChecking(TyR.get(), /*IsSILType=*/ false, GenericEnv);
+    if (Ty->hasError())
       return true;
-    parsed.push_back({Loc, Ty.getType()});
+    parsed.push_back({Loc, Ty});
   } while (P.consumeIf(tok::comma));
 
   // Consume the closing '>'.
@@ -2090,31 +2091,27 @@ bool SILParser::parseSILDeclRef(SILDeclRef &Member, bool FnTypeRequired) {
     GenericsScope.reset();
     if (TyR.isNull())
       return true;
-    TypeLoc Ty = TyR.get();
 
     // The type can be polymorphic.
     GenericEnvironment *genericEnv = nullptr;
     if (auto fnType = dyn_cast<FunctionTypeRepr>(TyR.get())) {
       if (auto generics = fnType->getGenericParams()) {
-        assert(!Ty.wasValidated() && Ty.getType().isNull());
-
         genericEnv = handleSILGenericParams(generics, &P.SF);
         fnType->setGenericEnvironment(genericEnv);
       }
       if (auto generics = fnType->getPatternGenericParams()) {
-        assert(!Ty.wasValidated() && Ty.getType().isNull());
-
         genericEnv = handleSILGenericParams(generics, &P.SF);
         fnType->setPatternGenericEnvironment(genericEnv);
       }
     }
 
-    if (performTypeLocChecking(Ty, /*IsSILType=*/ false, genericEnv))
+    auto Ty = performTypeLocChecking(TyR.get(), /*IsSILType=*/ false, genericEnv);
+    if (Ty->hasError())
       return true;
 
     // Pick the ValueDecl that has the right type.
     ValueDecl *TheDecl = nullptr;
-    auto declTy = Ty.getType()->getCanonicalType();
+    auto declTy = Ty->getCanonicalType();
     for (unsigned I = 0, E = values.size(); I < E; ++I) {
       auto *decl = values[I];
 
@@ -6306,14 +6303,13 @@ ProtocolConformanceRef SILParser::parseProtocolConformanceHelper(
   ParserResult<TypeRepr> TyR = P.parseType();
   if (TyR.isNull())
     return ProtocolConformanceRef();
-  TypeLoc Ty = TyR.get();
   if (defaultForProto) {
-    bindProtocolSelfInTypeRepr(Ty, defaultForProto);
+    bindProtocolSelfInTypeRepr(TyR.get(), defaultForProto);
   }
 
-  if (performTypeLocChecking(Ty, /*IsSILType=*/ false, witnessEnv))
+  auto ConformingTy = performTypeLocChecking(TyR.get(), /*IsSILType=*/ false, witnessEnv);
+  if (ConformingTy->hasError())
     return ProtocolConformanceRef();
-  auto ConformingTy = Ty.getType();
 
   if (P.parseToken(tok::colon, diag::expected_sil_witness_colon))
     return ProtocolConformanceRef();
@@ -6429,7 +6425,7 @@ static bool parseSILVTableEntry(
         return true;
       TypeLoc Ty = TyR.get();
       if (isDefaultWitnessTable)
-        bindProtocolSelfInTypeRepr(Ty, proto);
+        bindProtocolSelfInTypeRepr(TyR.get(), proto);
       if (swift::performTypeLocChecking(P.Context, Ty,
                                         /*isSILMode=*/false,
                                         /*isSILType=*/false,
@@ -6490,7 +6486,7 @@ static bool parseSILVTableEntry(
       return true;
     TypeLoc Ty = TyR.get();
     if (isDefaultWitnessTable)
-      bindProtocolSelfInTypeRepr(Ty, proto);
+      bindProtocolSelfInTypeRepr(TyR.get(), proto);
     if (swift::performTypeLocChecking(P.Context, Ty,
                                       /*isSILMode=*/false,
                                       /*isSILType=*/false,