Introduce a new representation of polymorphic function types.

Introduces a new kind of function type, GenericFunctionType, that
represents a polymorphic function type with all of its generic
parameters and requirements stored in a more readily canonicalizable
form. It is meant to eventually replace PolymorphicFunctionType, but
for now we build it up in parallel so we can switch over to it
pieacemeal.

Note: this representation is built and then thrown away. We'll start
recording it soon.


Swift SVN r8881

Author: DougGregor

include/swift/AST/ArchetypeBuilder.h

@@ -32,7 +32,7 @@ class ArchetypeType;
 class AssociatedTypeDecl;
 class Pattern;
 class ProtocolDecl;
-class Requirement;
+class RequirementRepr;
 class SourceLoc;
 class TranslationUnit;
 class Type;
@@ -104,6 +104,9 @@ class ArchetypeBuilder {
   ArchetypeBuilder(ArchetypeBuilder &&);
   ~ArchetypeBuilder();
 
+  /// Retrieve the translation unit.
+  TranslationUnit &getTranslationUnit() const { return TU; }
+
   /// \brief Add a new generic parameter for which there may be requirements.
   ///
   /// \returns true if an error occurred, false otherwise.
@@ -114,7 +117,7 @@ class ArchetypeBuilder {
   ///
   /// \returns true if this requirement makes the set of requirements
   /// inconsistent, in which case a diagnostic will have been issued.
-  bool addRequirement(const Requirement &Req);
+  bool addRequirement(const RequirementRepr &Req);
 
   /// \brief Add a new, implicit conformance requirement for one of the
   /// parameters.
@@ -180,7 +183,6 @@ class ArchetypeBuilder {
   /// list.
   ArrayRef<ArchetypeType *> getAllArchetypes();
 
-  // FIXME: Infer requirements from signatures
   // FIXME: Compute the set of 'extra' witness tables needed to express this
   // requirement set.
 
@@ -233,6 +235,10 @@ class ArchetypeBuilder::PotentialArchetype {
   /// \brief Retrieve the full display name of this potential archetype.
   std::string getFullName() const;
 
+  /// Retrieve the parent of this potential archetype, which will be non-null
+  /// when this potential archetype is an associated type.
+  PotentialArchetype *getParent() const { return Parent; }
+
   /// Retrieve the set of protocols to which this type conforms.
   ArrayRef<ProtocolDecl *> getConformsTo() const {
     return llvm::makeArrayRef(ConformsTo.begin(), ConformsTo.end());
@@ -241,6 +247,11 @@ class ArchetypeBuilder::PotentialArchetype {
   /// Retrieve the superclass of this archetype.
   Type getSuperclass() const { return Superclass; }
 
+  /// Retrieve the set of nested types.
+  const llvm::DenseMap<Identifier, PotentialArchetype*> &getNestedTypes() const{
+    return NestedTypes;
+  }
+
   /// \brief Determine the nesting depth of this potential archetype, e.g.,
   /// the number of associated type references.
   unsigned getNestingDepth() const;
@@ -257,6 +268,9 @@ class ArchetypeBuilder::PotentialArchetype {
   ArchetypeType *getArchetype(AssociatedTypeDecl * /*nullable*/ rootAssocTy,
                               TranslationUnit &tu);
 
+  /// Retrieve the associated type declaration for a given nested type.
+  AssociatedTypeDecl *getAssociatedType(TranslationUnit &tu, Identifier name);
+
   void dump(llvm::raw_ostream &Out, unsigned Indent);
 
   friend class ArchetypeBuilder;

include/swift/AST/Decl.h

@@ -23,6 +23,7 @@
 #include "swift/AST/DefaultArgumentKind.h"
 #include "swift/AST/KnownProtocols.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/Requirement.h"
 #include "swift/AST/Substitution.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeLoc.h"
@@ -427,30 +428,19 @@ class GenericParam {
   void setDeclContext(DeclContext *DC);
 };
 
-/// \brief Describes the kind of a requirement that occurs within a requirements
-/// clause.
-enum class RequirementKind : unsigned int {
-  /// \brief A conformance requirement T : P, where T is a type that depends
-  /// on a generic parameter and P is a protocol to which T must conform.
-  Conformance,
-  /// \brief A same-type requirement T == U, where T and U are types that
-  /// shall be equivalent.
-  SameType
-};
-
 /// \brief A single requirement in a 'where' clause, which places additional
 /// restrictions on the generic parameters or associated types of a generic
 /// function, type, or protocol.
 ///
 /// This always represents a requirement spelled in the source code.  It is
 /// never generated implicitly.
-class Requirement {
+class RequirementRepr {
   SourceLoc SeparatorLoc;
   RequirementKind Kind : 1;
   bool Invalid : 1;
   TypeLoc Types[2];
 
-  Requirement(SourceLoc SeparatorLoc, RequirementKind Kind, TypeLoc FirstType,
+  RequirementRepr(SourceLoc SeparatorLoc, RequirementKind Kind, TypeLoc FirstType,
               TypeLoc SecondType)
     : SeparatorLoc(SeparatorLoc), Kind(Kind), Invalid(false),
       Types{FirstType, SecondType} { }
@@ -464,7 +454,7 @@ class Requirement {
   /// this requirement was implied.
   /// \param Constraint The protocol or protocol composition to which the
   /// subject must conform, or superclass from which the subject must inherit.
-  static Requirement getConformance(TypeLoc Subject,
+  static RequirementRepr getConformance(TypeLoc Subject,
                                     SourceLoc ColonLoc,
                                     TypeLoc Constraint) {
     return { ColonLoc, RequirementKind::Conformance, Subject, Constraint };
@@ -476,7 +466,7 @@ class Requirement {
   /// \param EqualLoc The location of the '==' in the same-type constraint, or
   /// an invalid location if this requirement was implied.
   /// \param SecondType The second type.
-  static Requirement getSameType(TypeLoc FirstType,
+  static RequirementRepr getSameType(TypeLoc FirstType,
                                  SourceLoc EqualLoc,
                                  TypeLoc SecondType) {
     return { EqualLoc, RequirementKind::SameType, FirstType, SecondType };
@@ -589,15 +579,15 @@ class GenericParamList {
   SourceRange Brackets;
   unsigned NumParams;
   SourceLoc WhereLoc;
-  MutableArrayRef<Requirement> Requirements;
+  MutableArrayRef<RequirementRepr> Requirements;
   ArrayRef<ArchetypeType *> AllArchetypes;
 
   GenericParamList *OuterParameters;
 
   GenericParamList(SourceLoc LAngleLoc,
                    ArrayRef<GenericParam> Params,
                    SourceLoc WhereLoc,
-                   MutableArrayRef<Requirement> Requirements,
+                   MutableArrayRef<RequirementRepr> Requirements,
                    SourceLoc RAngleLoc);
 
 public:
@@ -630,7 +620,7 @@ class GenericParamList {
                                   SourceLoc LAngleLoc,
                                   ArrayRef<GenericParam> Params,
                                   SourceLoc WhereLoc,
-                                  MutableArrayRef<Requirement> Requirements,
+                                  MutableArrayRef<RequirementRepr> Requirements,
                                   SourceLoc RAngleLoc);
 
   MutableArrayRef<GenericParam> getParams() {
@@ -659,15 +649,15 @@ class GenericParamList {
   /// This list may contain both explicitly-written requirements as well as
   /// implicitly-generated requirements, and may be non-empty even if no
   /// 'where' keyword is present.
-  MutableArrayRef<Requirement> getRequirements() { return Requirements; }
+  MutableArrayRef<RequirementRepr> getRequirements() { return Requirements; }
 
   /// \brief Retrieve the set of additional requirements placed on these
   /// generic parameters and types derived from them.
   ///
   /// This list may contain both explicitly-written requirements as well as
   /// implicitly-generated requirements, and may be non-empty even if no
   /// 'where' keyword is present.
-  ArrayRef<Requirement> getRequirements() const { return Requirements; }
+  ArrayRef<RequirementRepr> getRequirements() const { return Requirements; }
 
   /// \brief Override the set of requirements associated with this generic
   /// parameter list.
@@ -676,7 +666,7 @@ class GenericParamList {
   /// to be a superset of the existing set of requirements (although this
   /// property is not checked here). It is assumed that the array reference
   /// refers to ASTContext-allocated memory.
-  void overrideRequirements(MutableArrayRef<Requirement> NewRequirements) {
+  void overrideRequirements(MutableArrayRef<RequirementRepr> NewRequirements) {
     Requirements = NewRequirements;
   }
 
@@ -887,8 +877,8 @@ class ExtensionDecl : public Decl, public DeclContext {
   }
 
   /// Note that we have already type-checked the inheritance clause.
-  void setCheckedInheritanceClause() {
-    ExtensionDeclBits.CheckedInheritanceClause = true;
+  void setCheckedInheritanceClause(bool checked = true) {
+    ExtensionDeclBits.CheckedInheritanceClause = checked;
   }
 
   /// \brief Retrieve the set of protocols to which this extension conforms.
@@ -1158,8 +1148,8 @@ class TypeDecl : public ValueDecl {
   }
 
   /// Note that we have already type-checked the inheritance clause.
-  void setCheckedInheritanceClause() {
-    TypeDeclBits.CheckedInheritanceClause = true;
+  void setCheckedInheritanceClause(bool checked = true) {
+    TypeDeclBits.CheckedInheritanceClause = checked;
   }
 
   /// \brief Retrieve the set of protocols to which this type conforms.

include/swift/AST/Requirement.h

@@ -0,0 +1,63 @@
+//===--- Requirement.h - Swift Requirement ASTs -----------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the Requirement class and subclasses.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_REQUIREMENT_H
+#define SWIFT_AST_REQUIREMENT_H
+
+#include "swift/AST/Type.h"
+#include "llvm/ADT/PointerIntPair.h"
+
+namespace swift {
+
+/// \brief Describes the kind of a requirement that occurs within a requirements
+/// clause.
+enum class RequirementKind : unsigned int {
+  /// \brief A conformance requirement T : P, where T is a type that depends
+  /// on a generic parameter and P is a protocol to which T must conform.
+  Conformance,
+  /// \brief A same-type requirement T == U, where T and U are types that
+  /// shall be equivalent.
+  SameType
+};
+
+/// \brief A single requirement placed on the type parameters (or associated
+/// types thereof) of a
+class Requirement {
+  llvm::PointerIntPair<Type, 1, RequirementKind> FirstTypeAndKind;
+  Type SecondType;
+
+public:
+  /// Create a conformance or same-type requirement.
+  Requirement(RequirementKind kind, Type first, Type second)
+  : FirstTypeAndKind(first, kind), SecondType(second) { }
+
+  /// \brief Determine the kind of requirement.
+  RequirementKind getKind() const { return FirstTypeAndKind.getInt(); }
+
+  /// \brief Retrieve the first type.
+  Type getFirstType() const {
+    return FirstTypeAndKind.getPointer();
+  }
+
+  /// \brief Retrieve the second type.
+  Type getSecondType() const {
+    return SecondType;
+  }
+};
+
+} // end namespace swift
+
+#endif

include/swift/AST/TypeNodes.def

@@ -117,7 +117,8 @@ TYPE(DependentMember, Type)
 ABSTRACT_TYPE(AnyFunction, Type)
   TYPE(Function, AnyFunctionType)
   TYPE(PolymorphicFunction, AnyFunctionType)
-  TYPE_RANGE(AnyFunction, Function, PolymorphicFunction)
+  TYPE(GenericFunction, AnyFunctionType)
+  TYPE_RANGE(AnyFunction, Function, GenericFunction)
 TYPE(Array, Type)
 ABSTRACT_SUGARED_TYPE(SyntaxSugar, Type)
   SUGARED_TYPE(ArraySlice, SyntaxSugarType)