Remove support for nominal type patterns, which have never been supported in an

official swift release and have bitrotted.

Author: lattner

include/swift/AST/DiagnosticsSema.def

@@ -2456,21 +2456,6 @@ ERROR(condition_optional_element_pattern_not_valid_type,none,
       (Type))
 ERROR(enum_element_pattern_not_member_of_enum,none,
       "enum case '%0' is not a member of type %1", (StringRef, Type))
-ERROR(nominal_type_pattern_not_nominal_type,none,
-      "non-nominal type %0 cannot be used with property pattern syntax", (Type))
-ERROR(nominal_type_pattern_type_mismatch,none,
-      "type %0 of pattern does not match deduced type %1", (Type, Type))
-ERROR(nominal_type_pattern_property_not_found,none,
-      "property '%0' not found in type %1", (StringRef, Type))
-ERROR(nominal_type_pattern_property_ambiguous,none,
-      "property name '%0' in type %1 is ambiguous", (StringRef, Type))
-ERROR(nominal_type_pattern_not_property,none,
-      "member '%0' of type %1 is not a property", (StringRef, Type))
-ERROR(nominal_type_pattern_static_property,none,
-      "cannot match type property '%0' of type %1 in a 'case' pattern",
-      (StringRef, Type))
-ERROR(nominal_type_subpattern_without_property_name,none,
-      "subpattern of a struct or class pattern must have a keyword name", ())
 ERROR(ambiguous_enum_pattern_type,none,
       "generic enum type %0 is ambiguous without explicit generic parameters "
       "when matching value of type %1", (Type, Type))

include/swift/AST/Pattern.h

@@ -451,102 +451,6 @@ class IsPattern : public Pattern {
     return P->getKind() == PatternKind::Is;
   }
 };
-
-namespace detail {
-  /// A nominal type subpattern record.
-  class NominalTypePatternElement {
-    /// The location of the property name.
-    SourceLoc PropertyLoc;
-    /// The location of the colon.
-    SourceLoc ColonLoc;
-    /// The referenced property name.
-    Identifier PropertyName;
-    /// The referenced property.
-    VarDecl *Property;
-    /// The subpattern.
-    Pattern *SubPattern;
-  public:
-    NominalTypePatternElement(SourceLoc PropLoc, Identifier PropName,
-                              VarDecl *Prop, SourceLoc ColonLoc, Pattern *SubP)
-      : PropertyLoc(PropLoc), ColonLoc(ColonLoc),
-        PropertyName(PropName), Property(Prop),
-        SubPattern(SubP)
-    {}
-    
-    SourceLoc getPropertyLoc() const { return PropertyLoc; }
-    SourceLoc getColonLoc() const { return ColonLoc; }
-    
-    VarDecl *getProperty() const { return Property; }
-    void setProperty(VarDecl *v) { Property = v; }
-    
-    Identifier getPropertyName() const { return PropertyName; }
-    
-    const Pattern *getSubPattern() const { return SubPattern; }
-    Pattern *getSubPattern() { return SubPattern; }
-    void setSubPattern(Pattern *p) { SubPattern = p; }
-  };
-} // end namespace detail
-  
-/// A pattern that matches a nominal type and destructures elements out of it.
-/// The match succeeds if the loaded property values all match their associated
-/// subpatterns.
-class NominalTypePattern final : public Pattern,
-    private llvm::TrailingObjects<NominalTypePattern,
-                                  detail::NominalTypePatternElement> {
-  friend TrailingObjects;
-
-public:
-  /// A nominal type subpattern record.
-  using Element = detail::NominalTypePatternElement;
-
-private:
-  TypeLoc CastType;
-  SourceLoc LParenLoc, RParenLoc;
-  
-  unsigned NumElements;
-
-  NominalTypePattern(TypeLoc CastTy, SourceLoc LParenLoc,
-                     ArrayRef<Element> Elements,
-                     SourceLoc RParenLoc,
-                     Optional<bool> implicit = None)
-    : Pattern(PatternKind::NominalType), CastType(CastTy),
-      LParenLoc(LParenLoc), RParenLoc(RParenLoc),
-      NumElements(Elements.size())
-  {
-    if (implicit.hasValue() ? *implicit : !CastTy.hasLocation())
-      setImplicit();
-    std::uninitialized_copy(Elements.begin(), Elements.end(),
-                            getTrailingObjects<Element>());
-  }
-  
-public:
-  static NominalTypePattern *create(TypeLoc CastTy, SourceLoc LParenLoc,
-                                    ArrayRef<Element> Elements,
-                                    SourceLoc RParenLoc,
-                                    ASTContext &C,
-                                    Optional<bool> implicit = None);
-
-  TypeLoc &getCastTypeLoc() { return CastType; }
-  TypeLoc getCastTypeLoc() const { return CastType; }
-  
-  ArrayRef<Element> getElements() const {
-    return {getTrailingObjects<Element>(), NumElements};
-  }
-  MutableArrayRef<Element> getMutableElements() {
-    return {getTrailingObjects<Element>(), NumElements};
-  }
-  
-  SourceLoc getLoc() const { return CastType.getSourceRange().Start; }
-  SourceLoc getLParenLoc() const { return LParenLoc; }
-  SourceLoc getRParenLoc() const { return RParenLoc; }
-  SourceRange getSourceRange() const {
-    return {getLoc(), RParenLoc};
-  }
-  
-  static bool classof(const Pattern *P) {
-    return P->getKind() == PatternKind::NominalType;
-  }
-};
 
 /// A pattern that matches an enum case. If the enum value is in the matching
 /// case, then the value is extracted. If there is a subpattern, it is then

include/swift/AST/PatternNodes.def

@@ -35,7 +35,6 @@ PATTERN(Any, Pattern)
 PATTERN(Typed, Pattern)
 PATTERN(Var, Pattern)
 REFUTABLE_PATTERN(Is, Pattern)
-REFUTABLE_PATTERN(NominalType, Pattern)
 REFUTABLE_PATTERN(EnumElement, Pattern)
 REFUTABLE_PATTERN(OptionalSome, Pattern)
 REFUTABLE_PATTERN(Bool, Pattern)

include/swift/Basic/LangOptions.h

@@ -136,9 +136,6 @@ namespace swift {
     /// \brief Perform all dynamic allocations using malloc/free instead of
     /// optimized custom allocator, so that memory debugging tools can be used.
     bool UseMalloc = false;
-    
-    /// \brief Enable experimental "switch" pattern-matching features.
-    bool EnableExperimentalPatterns = false;
 
     /// \brief Enable experimental property behavior feature.
     bool EnableExperimentalPropertyBehaviors = false;

include/swift/Option/FrontendOptions.td

@@ -223,9 +223,6 @@ def dump_clang_diagnostics : Flag<["-"], "dump-clang-diagnostics">,
 def emit_verbose_sil : Flag<["-"], "emit-verbose-sil">,
   HelpText<"Emit locations during SIL emission">;
 
-def enable_experimental_patterns : Flag<["-"], "enable-experimental-patterns">,
-  HelpText<"Enable experimental 'switch' pattern matching features">;
-
 def enable_experimental_property_behaviors :
   Flag<["-"], "enable-experimental-property-behaviors">,
   HelpText<"Enable experimental property behaviors">;

include/swift/Serialization/DeclTypeRecordNodes.def

@@ -147,8 +147,6 @@ PATTERN(NAMED)
 PATTERN(ANY)
 PATTERN(TYPED)
 PATTERN(ISA)
-PATTERN(NOMINAL_TYPE)
-TRAILING_INFO(NOMINAL_TYPE_PATTERN_ELT)
 PATTERN(VAR)
 
 OTHER(PARAMETERLIST, 226)

include/swift/Serialization/ModuleFormat.h

@@ -1073,20 +1073,6 @@ namespace decls_block {
     BCFixed<1>   // implicit?
   >;
 
-  using NominalTypePatternLayout = BCRecordLayout<
-    NOMINAL_TYPE_PATTERN,
-    TypeIDField, // type
-    BCVBR<5>, // number of elements
-    BCFixed<1>  // implicit?
-    // The elements trail the record.
-  >;
-
-  using NominalTypePatternEltLayout = BCRecordLayout<
-    NOMINAL_TYPE_PATTERN_ELT,
-    DeclIDField // property
-    // The element pattern trails the record.
-  >;
-
   using VarPatternLayout = BCRecordLayout<
     VAR_PATTERN,
     BCFixed<1>, // isLet?

lib/AST/ASTDumper.cpp

@@ -310,17 +310,6 @@ namespace {
       }
       OS << ')';
     }
-    void visitNominalTypePattern(NominalTypePattern *P) {
-      printCommon(P, "pattern_nominal") << ' ';
-      P->getCastTypeLoc().getType().print(OS);
-      // FIXME: We aren't const-correct.
-      for (auto &elt : P->getMutableElements()) {
-        OS << '\n';
-        OS.indent(Indent) << elt.getPropertyName() << ": ";
-        printRec(elt.getSubPattern());
-      }
-      OS << ')';
-    }
     void visitExprPattern(ExprPattern *P) {
       printCommon(P, "pattern_expr");
       OS << '\n';

lib/AST/ASTPrinter.cpp

@@ -1377,20 +1377,6 @@ void PrintAST::printPattern(const Pattern *pattern) {
     break;
   }
 
-  case PatternKind::NominalType: {
-    auto type = cast<NominalTypePattern>(pattern);
-    type->getCastTypeLoc().getType().print(Printer, Options);
-    Printer << "(";
-    interleave(type->getElements().begin(), type->getElements().end(),
-               [&](const NominalTypePattern::Element &elt) {
-                 Printer << elt.getPropertyName().str() << ":";
-                 printPattern(elt.getSubPattern());
-               }, [&] {
-                 Printer << ", ";
-               });
-    break;
-  }
-
   case PatternKind::EnumElement: {
     auto elt = cast<EnumElementPattern>(pattern);
     // FIXME: Print element expr.

lib/AST/ASTWalker.cpp

@@ -1413,16 +1413,6 @@ Pattern *Traversal::visitIsPattern(IsPattern *P) {
   return P;
 }
 
-Pattern *Traversal::visitNominalTypePattern(NominalTypePattern *P) {
-  for (auto &elt : P->getMutableElements()) {
-    if (Pattern *newSub = doIt(elt.getSubPattern()))
-      elt.setSubPattern(newSub);
-    else
-      return nullptr;
-  }
-  return P;
-}
-
 Pattern *Traversal::visitEnumElementPattern(EnumElementPattern *P) {
   if (!P->hasSubPattern())
     return P;

lib/AST/NameLookupImpl.h

@@ -60,12 +60,6 @@ class FindLocalVal : public StmtVisitor<FindLocalVal> {
       return checkPattern(Pat->getSemanticsProvidingPattern(), Reason);
     case PatternKind::Named:
       return checkValueDecl(cast<NamedPattern>(Pat)->getDecl(), Reason);
-
-    case PatternKind::NominalType: {
-      for (auto &elt : cast<NominalTypePattern>(Pat)->getElements())
-        checkPattern(elt.getSubPattern(), Reason);
-      return;
-    }
     case PatternKind::EnumElement: {
       auto *OP = cast<EnumElementPattern>(Pat);
       if (OP->hasSubPattern())

lib/AST/Pattern.cpp

@@ -37,8 +37,6 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &OS, PatternKind kind) {
     return OS << "pattern type annotation";
   case PatternKind::Is:
     return OS << "prefix 'is' pattern";
-  case PatternKind::NominalType:
-    return OS << "type destructuring pattern";
   case PatternKind::Expr:
     return OS << "expression pattern";
   case PatternKind::Var:
@@ -167,11 +165,6 @@ void Pattern::forEachVariable(const std::function<void(VarDecl*)> &fn) const {
       elt.getPattern()->forEachVariable(fn);
     return;
 
-  case PatternKind::NominalType:
-    for (auto elt : cast<NominalTypePattern>(this)->getElements())
-      elt.getSubPattern()->forEachVariable(fn);
-    return;
-
   case PatternKind::EnumElement:
     if (auto SP = cast<EnumElementPattern>(this)->getSubPattern())
       SP->forEachVariable(fn);
@@ -220,11 +213,6 @@ void Pattern::forEachNode(const std::function<void(Pattern*)> &f) {
       elt.getPattern()->forEachNode(f);
     return;
 
-  case PatternKind::NominalType:
-    for (auto elt : cast<NominalTypePattern>(this)->getElements())
-      elt.getSubPattern()->forEachNode(f);
-    return;
-
   case PatternKind::EnumElement: {
     auto *OP = cast<EnumElementPattern>(this);
     if (OP->hasSubPattern())
@@ -374,14 +362,3 @@ SourceRange TypedPattern::getSourceRange() const {
   return { SubPattern->getSourceRange().Start, PatType.getSourceRange().End };
 }
 
-NominalTypePattern *NominalTypePattern::create(TypeLoc CastTy,
-                                               SourceLoc LParenLoc,
-                                               ArrayRef<Element> Elements,
-                                               SourceLoc RParenLoc,
-                                               ASTContext &C,
-                                               Optional<bool> implicit) {
-  void *buf = C.Allocate(totalSizeToAlloc<Element>(Elements.size()),
-                         alignof(Element));
-  return ::new (buf) NominalTypePattern(CastTy, LParenLoc, Elements, RParenLoc,
-                                        implicit);
-}

lib/Frontend/CompilerInvocation.cpp

@@ -734,9 +734,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.UseMalloc |= Args.hasArg(OPT_use_malloc);
 
-  Opts.EnableExperimentalPatterns |=
-    Args.hasArg(OPT_enable_experimental_patterns);
-
   Opts.EnableExperimentalPropertyBehaviors |=
     Args.hasArg(OPT_enable_experimental_property_behaviors);
 

lib/SILGen/SILGenDecl.cpp

@@ -918,10 +918,6 @@ struct InitializationForPattern
   InitializationPtr visitExprPattern(ExprPattern *P) {
     return InitializationPtr(new ExprPatternInitialization(P, patternFailDest));
   }
-  InitializationPtr visitNominalTypePattern(NominalTypePattern *P) {
-    P->dump();
-    llvm_unreachable("pattern not supported in let/else yet");
-  }
 };
 
 } // end anonymous namespace