[AST] Introduce a new type that has associated location in source

This type is intended to be used to wrap compiler synthesized nodes
(i.e. variables) to make it easier for diagnostic to diagnose precise
failure locations.

Consider the situation like:

```
protocol P {}

extension Array: P where Element: P {}

func test<T: P>() -> T {
  $_a = ...
  $_b = ...
  return [$_a, $_b]
}
```

This is a common pattern with result builders.

In this case if one of the elements don't conform to `P` the best
user experience would be to attach diagnostic to the element otherwise
the developers would have to figure out where in result expression
the error occured before attempting to fix it.

Author: xedin

include/swift/AST/TypeNodes.def

@@ -210,6 +210,7 @@ UNCHECKED_TYPE(ErrorUnion, Type)
 ALWAYS_CANONICAL_TYPE(Integer, Type)
 ABSTRACT_SUGARED_TYPE(Sugar, Type)
   SUGARED_TYPE(TypeAlias, SugarType)
+  SUGARED_TYPE(Locatable, SugarType)
   ABSTRACT_SUGARED_TYPE(SyntaxSugar, SugarType)
     ABSTRACT_SUGARED_TYPE(UnarySyntaxSugar, SyntaxSugarType)
       SUGARED_TYPE(ArraySlice, UnarySyntaxSugarType)

include/swift/AST/TypeTransform.h

@@ -533,6 +533,19 @@ case TypeKind::Id:
                                 newUnderlyingTy);
     }
 
+    case TypeKind::Locatable: {
+      auto locatable = cast<LocatableType>(base);
+      Type oldUnderlyingTy = Type(locatable->getSinglyDesugaredType());
+      Type newUnderlyingTy = doIt(oldUnderlyingTy, pos);
+      if (!newUnderlyingTy)
+        return Type();
+
+      if (oldUnderlyingTy.getPointer() == newUnderlyingTy.getPointer())
+        return t;
+
+      return LocatableType::get(locatable->getLoc(), newUnderlyingTy);
+    }
+
     case TypeKind::ErrorUnion: {
       auto errorUnion = cast<ErrorUnionType>(base);
       bool anyChanged = false;

include/swift/AST/Types.h

@@ -84,6 +84,7 @@ enum class ReferenceCounting : uint8_t;
 enum class ResilienceExpansion : unsigned;
 class SILModule;
 class SILType;
+class SourceLoc;
 class TypeAliasDecl;
 class TypeDecl;
 class NominalTypeDecl;
@@ -2322,6 +2323,28 @@ class TypeAliasType final
   }
 };
 
+/// A type has been introduced at some fixed location in the AST.
+class LocatableType final : public SugarType, public llvm::FoldingSetNode {
+  SourceLoc Loc;
+
+  LocatableType(SourceLoc loc, Type underlying,
+                RecursiveTypeProperties properties);
+
+public:
+  SourceLoc getLoc() const { return Loc; }
+
+  static LocatableType *get(SourceLoc loc, Type underlying);
+
+  void Profile(llvm::FoldingSetNodeID &id) const;
+
+  static void Profile(llvm::FoldingSetNodeID &id, SourceLoc loc,
+                      Type underlying);
+
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::Locatable;
+  }
+};
+
 /// The various spellings of ownership modifier that can be used in source.
 enum class ParamSpecifier : uint8_t {
   /// No explicit ownership specifier was provided. The parameter will use the

lib/AST/ASTContext.cpp

@@ -530,6 +530,7 @@ struct ASTContext::Implementation {
 
     llvm::DenseMap<Type, ErrorType *> ErrorTypesWithOriginal;
     llvm::FoldingSet<TypeAliasType> TypeAliasTypes;
+    llvm::FoldingSet<LocatableType> LocatableTypes;
     llvm::FoldingSet<TupleType> TupleTypes;
     llvm::FoldingSet<PackType> PackTypes;
     llvm::FoldingSet<PackExpansionType> PackExpansionTypes;
@@ -3270,6 +3271,7 @@ void ASTContext::Implementation::Arena::dump(llvm::raw_ostream &os) const {
 
     SIZE_AND_BYTES(ErrorTypesWithOriginal);
     SIZE(TypeAliasTypes);
+    SIZE(LocatableTypes);
     SIZE(TupleTypes);
     SIZE(PackTypes);
     SIZE(PackExpansionTypes);
@@ -3452,6 +3454,45 @@ void TypeAliasType::Profile(
   id.AddPointer(underlying.getPointer());
 }
 
+LocatableType::LocatableType(SourceLoc loc, Type underlying,
+                             RecursiveTypeProperties properties)
+    : SugarType(TypeKind::Locatable, underlying, properties), Loc(loc) {
+  ASSERT(loc.isValid());
+}
+
+LocatableType *LocatableType::get(SourceLoc loc, Type underlying) {
+  auto properties = underlying->getRecursiveProperties();
+
+  // Figure out which arena this type will go into.
+  auto &ctx = underlying->getASTContext();
+  auto arena = getArena(properties);
+
+  // Profile the type.
+  llvm::FoldingSetNodeID id;
+  LocatableType::Profile(id, loc, underlying);
+
+  // Did we already record this type?
+  void *insertPos;
+  auto &types = ctx.getImpl().getArena(arena).LocatableTypes;
+  if (auto result = types.FindNodeOrInsertPos(id, insertPos))
+    return result;
+
+  // Build a new type.
+  auto result = new (ctx, arena) LocatableType(loc, underlying, properties);
+  types.InsertNode(result, insertPos);
+  return result;
+}
+
+void LocatableType::Profile(llvm::FoldingSetNodeID &id) const {
+  Profile(id, Loc, Type(getSinglyDesugaredType()));
+}
+
+void LocatableType::Profile(llvm::FoldingSetNodeID &id, SourceLoc loc,
+                            Type underlying) {
+  id.AddPointer(loc.getOpaquePointerValue());
+  id.AddPointer(underlying.getPointer());
+}
+
 // Simple accessors.
 Type ErrorType::get(const ASTContext &C) { return C.TheErrorType; }
 

lib/AST/ASTDumper.cpp

@@ -4098,6 +4098,18 @@ namespace {
       printFoot();
     }
 
+    void visitLocatableType(LocatableType *T, StringRef label) {
+      printCommon("locatable_type", label);
+      printFieldQuotedRaw(
+          [&](raw_ostream &OS) {
+            auto &C = T->getASTContext();
+            T->getLoc().print(OS, C.SourceMgr);
+          },
+          "loc");
+      printRec(T->getSinglyDesugaredType(), "underlying");
+      printFoot();
+    }
+
     void visitPackType(PackType *T, StringRef label) {
       printCommon("pack_type", label);
 

lib/AST/ASTMangler.cpp

@@ -1296,6 +1296,7 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     case TypeKind::BuiltinUnsafeValueBuffer:
       return appendOperator("BB");
     case TypeKind::BuiltinUnboundGeneric:
+    case TypeKind::Locatable:
       llvm_unreachable("not a real type");
     case TypeKind::BuiltinFixedArray: {
       auto bfa = cast<BuiltinFixedArrayType>(tybase);

lib/AST/ASTPrinter.cpp

@@ -6009,6 +6009,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  void visitLocatableType(LocatableType *T) {
+    visit(T->getSinglyDesugaredType());
+  }
+
   void visitPackType(PackType *T) {
     if (Options.PrintExplicitPackTypes || Options.PrintTypesForDebugging)
       Printer << "Pack{";

lib/AST/Type.cpp

@@ -1921,6 +1921,8 @@ Type SugarType::getSinglyDesugaredTypeSlow() {
 #include "swift/AST/TypeNodes.def"
   case TypeKind::TypeAlias:
     llvm_unreachable("bound type alias types always have an underlying type");
+  case TypeKind::Locatable:
+    llvm_unreachable("locatable types always have an underlying type");
   case TypeKind::ArraySlice:
   case TypeKind::VariadicSequence:
     implDecl = Context->getArrayDecl();

lib/AST/TypeWalker.cpp

@@ -50,6 +50,7 @@ class Traversal : public TypeVisitor<Traversal, bool>
     return false;
 
   }
+  bool visitLocatableType(LocatableType *ty) { return false; }
   bool visitSILTokenType(SILTokenType *ty) { return false; }
 
   bool visitPackType(PackType *ty) {

lib/IRGen/IRGenDebugInfo.cpp

@@ -2213,6 +2213,12 @@ createSpecializedStructOrClassType(NominalOrBoundGenericNominalType *Type,
                                     L.File, 0, Scope);
     }
 
+    case TypeKind::Locatable: {
+      auto *Sugar = cast<LocatableType>(BaseTy);
+      auto *CanTy = Sugar->getSinglyDesugaredType();
+      return getOrCreateDesugaredType(CanTy, DbgTy);
+    }
+
     // SyntaxSugarType derivations.
     case TypeKind::Dictionary:
     case TypeKind::ArraySlice: