IRGen: Encapsulate fields of GenericRequirement better

Author: slavapestov

include/swift/AST/GenericRequirement.h

@@ -0,0 +1,112 @@
+//===--- GenericRequirement.h - Generic requirement -------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_GENERIC_REQUIREMENT_H
+#define SWIFT_AST_GENERIC_REQUIREMENT_H
+
+#include "swift/AST/Type.h"
+
+namespace swift {
+
+class ProtocolDecl;
+
+/// The three kinds of entities passed in the runtime calling convention for
+/// generic code: pack shapes, type metadata, and witness tables.
+///
+/// A pack shape describes an equivalence class of type parameter packs; the
+/// runtime value is a single integer, which is the length of the pack.
+///
+/// Type metadata is emitted for each reduced generic parameter (that is,
+/// not same-type constrained to another generic parameter or concrete type).
+///
+/// A witness table is emitted for each conformance requirement in the
+/// generic signature.
+class GenericRequirement {
+public:
+  enum class Kind: uint8_t {
+    Shape,
+    Metadata,
+    WitnessTable
+  };
+
+private:
+  Kind kind;
+  CanType type;
+  ProtocolDecl *proto;
+
+  GenericRequirement(Kind kind, CanType type, ProtocolDecl *proto)
+    : kind(kind), type(type), proto(proto) {}
+
+public:
+  Kind getKind() const {
+    return kind;
+  }
+
+  CanType getTypeParameter() const {
+    return type;
+  }
+
+  ProtocolDecl *getProtocol() const {
+    return proto;
+  }
+
+  bool isShape() const {
+    return kind == Kind::Shape;
+  }
+
+  static GenericRequirement forShape(CanType type) {
+    return GenericRequirement(Kind::Shape, type, nullptr);
+  }
+
+  bool isMetadata() const {
+    return kind == Kind::Metadata;
+  }
+
+  static GenericRequirement forMetadata(CanType type) {
+    return GenericRequirement(Kind::Metadata, type, nullptr);
+  }
+
+  bool isWitnessTable() const {
+    return kind == Kind::WitnessTable;
+  }
+
+  static GenericRequirement forWitnessTable(CanType type, ProtocolDecl *proto) {
+    assert(proto != nullptr);
+    return GenericRequirement(Kind::WitnessTable, type, proto);
+  }
+};
+
+} // end namespace swift
+
+namespace llvm {
+template <> struct DenseMapInfo<swift::GenericRequirement> {
+  using GenericRequirement = swift::GenericRequirement;
+  using CanTypeInfo = llvm::DenseMapInfo<swift::CanType>;
+  static GenericRequirement getEmptyKey() {
+    return GenericRequirement::forMetadata(CanTypeInfo::getEmptyKey());
+  }
+  static GenericRequirement getTombstoneKey() {
+    return GenericRequirement::forMetadata(CanTypeInfo::getTombstoneKey());
+  }
+  static llvm::hash_code getHashValue(GenericRequirement req) {
+    return hash_combine(CanTypeInfo::getHashValue(req.getTypeParameter()),
+                        hash_value(req.getProtocol()));
+  }
+  static bool isEqual(GenericRequirement lhs, GenericRequirement rhs) {
+    return (lhs.getKind() == rhs.getKind() &&
+            lhs.getTypeParameter() == rhs.getTypeParameter() &&
+            lhs.getProtocol() == rhs.getProtocol());
+  }
+};
+} // end namespace llvm
+
+#endif // SWIFT_AST_GENERIC_REQUIREMENT_H

include/swift/IRGen/GenericRequirement.h

@@ -14,9 +14,9 @@
 #define SWIFT_IRGEN_IRABIDETAILSPROVIDER_H
 
 #include "swift/AST/Decl.h"
-#include "swift/AST/GenericRequirement.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
+#include "swift/IRGen/GenericRequirement.h"
 #include "clang/AST/CharUnits.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"

include/swift/IRGen/IRABIDetailsProvider.h

@@ -18,7 +18,7 @@ class Value;
 
 namespace swift {
 
-struct GenericRequirement;
+class GenericRequirement;
 class SILArgument;
 
 namespace irgen {

lib/IRGen/EntryPointArgumentEmission.h

@@ -435,14 +435,15 @@ withOpaqueTypeGenericArgs(IRGenFunction &IGF,
     enumerateGenericSignatureRequirements(
         opaqueDecl->getGenericSignature().getCanonicalSignature(),
         [&](GenericRequirement reqt) {
-          auto ty = reqt.TypeParameter.subst(archetype->getSubstitutions())
+          auto ty = reqt.getTypeParameter().subst(archetype->getSubstitutions())
                         ->getReducedType(opaqueDecl->getGenericSignature());
-          if (reqt.Protocol) {
+          if (reqt.isWitnessTable()) {
             auto ref =
-                ProtocolConformanceRef(reqt.Protocol)
-                    .subst(reqt.TypeParameter, archetype->getSubstitutions());
+                ProtocolConformanceRef(reqt.getProtocol())
+                    .subst(reqt.getTypeParameter(), archetype->getSubstitutions());
             args.push_back(emitWitnessTableRef(IGF, ty, ref));
           } else {
+            assert(reqt.isMetadata());
             args.push_back(IGF.emitAbstractTypeMetadataRef(ty));
           }
           types.push_back(args.back()->getType());

lib/IRGen/GenArchetype.cpp

@@ -886,7 +886,7 @@ emitKeyPathComponent(IRGenModule &IGM,
         enumerateGenericSignatureRequirements(
             componentCanSig, [&](GenericRequirement reqt) {
               auto substType =
-                  reqt.TypeParameter.subst(subs)->getCanonicalType();
+                  reqt.getTypeParameter().subst(subs)->getCanonicalType();
 
               // FIXME: This seems wrong. We used to just mangle opened archetypes as
               // their interface type. Let's make that explicit now.
@@ -896,14 +896,17 @@ emitKeyPathComponent(IRGenModule &IGM,
                 return None;
               })->getCanonicalType();
 
-              if (!reqt.Protocol) {
+              if (reqt.isMetadata()) {
                 // Type requirement.
                 externalSubArgs.push_back(emitMetadataTypeRefForKeyPath(
                     IGM, substType, componentCanSig));
               } else {
+                assert(reqt.isWitnessTable());
+
                 // Protocol requirement.
                 auto conformance = subs.lookupConformance(
-                    reqt.TypeParameter->getCanonicalType(), reqt.Protocol);
+                    reqt.getTypeParameter()->getCanonicalType(),
+                    reqt.getProtocol());
                 externalSubArgs.push_back(IGM.emitWitnessTableRefString(
                     substType, conformance,
                     genericEnv ? genericEnv->getGenericSignature() : nullptr,

lib/IRGen/GenKeyPath.cpp

@@ -4250,20 +4250,21 @@ namespace {
     }
 
     void addGenericArgument(GenericRequirement requirement) {
-      auto t = requirement.TypeParameter.subst(genericSubstitutions());
+      auto t = requirement.getTypeParameter().subst(genericSubstitutions());
       ConstantReference ref = IGM.getAddrOfTypeMetadata(
           CanType(t), SymbolReferenceKind::Relative_Direct);
       this->B.add(ref.getDirectValue());
     }
 
     void addGenericWitnessTable(GenericRequirement requirement) {
       auto conformance = genericSubstitutions().lookupConformance(
-          requirement.TypeParameter->getCanonicalType(), requirement.Protocol);
+          requirement.getTypeParameter()->getCanonicalType(),
+          requirement.getProtocol());
       ProtocolConformance *concreteConformance = conformance.getConcrete();
 
       llvm::Constant *addr;
 
-      Type argument = requirement.TypeParameter.subst(genericSubstitutions());
+      Type argument = requirement.getTypeParameter().subst(genericSubstitutions());
       auto argumentNominal = argument->getAnyNominal();
       if (argumentNominal && argumentNominal->isGenericContext()) {
         // TODO: Statically specialize the witness table pattern for t's