[Sema] Don't issue warnings when accessing enum elements as instance members

ahoppen · ahoppen · commit 232fe59b54ba · 2016-07-20T16:25:57.000+02:00
This removes the logic which issued warnings when accessing enum elements as instance members (SE-0036), making room for a new implementation that will issue errors instead. This reverts commit ae1058a.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -93,10 +93,6 @@ ERROR(could_not_use_type_member,none,
 ERROR(could_not_use_type_member_on_instance,none,
       "static member %1 cannot be used on instance of type %0",
       (Type, DeclName))
-WARNING(could_not_use_enum_element_on_instance,none,
-      "referencing enum element %0 as instance member is deprecated and will "
-      "be removed in Swift 3",
-      (DeclName))
 ERROR(could_not_use_type_member_on_existential,none,
       "static member %1 cannot be used on protocol metatype %0",
       (Type, DeclName))
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -1031,13 +1031,6 @@ class TypeExpr : public Expr {
   TypeLoc Info;
   TypeExpr(Type Ty);
 public:
-  /// Whether this type reference actually references an instance but has been
-  /// promoted to a type reference to access an enum element
-  ///
-  /// This is purely transitional and will be removed when referencing enum
-  /// elements on instance members becomes an error
-  bool IsPromotedInstanceRef = false;
-
   // Create a TypeExpr with location information.
   TypeExpr(TypeLoc Ty);
 
@@ -1058,8 +1051,7 @@ class TypeExpr : public Expr {
   
   /// Return a TypeExpr for a TypeDecl and the specified location.
   static TypeExpr *createForDecl(SourceLoc Loc, TypeDecl *D,
-                                 bool isImplicit,
-                                 bool isPromotedInstanceRef = false);
+                                 bool isImplicit);
   static TypeExpr *createForSpecializedDecl(SourceLoc Loc, TypeDecl *D,
                                             ArrayRef<TypeRepr*> args,
                                             SourceRange angleLocs);
diff --git a/include/swift/AST/NameLookup.h b/include/swift/AST/NameLookup.h
@@ -41,13 +41,6 @@ struct UnqualifiedLookupResult {
   ValueDecl *Value;
 
 public:
-  /// Whether this should actually reference an instance but has been promoted
-  /// to a type reference to access an enum element
-  ///
-  /// This is purely transitional and will be removed when referencing enum
-  /// elements on instance members becomes an error
-  bool IsPromotedInstanceRef = false;
-
   UnqualifiedLookupResult(ValueDecl *value) : Base(nullptr), Value(value) { }
 
   UnqualifiedLookupResult(ValueDecl *base, ValueDecl *value)
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -1345,14 +1345,12 @@ Type TypeExpr::getInstanceType() const {
 
 /// Return a TypeExpr for a simple identifier and the specified location.
 TypeExpr *TypeExpr::createForDecl(SourceLoc Loc, TypeDecl *Decl,
-                                  bool isImplicit,
-                                  bool isPromotedInstanceRef) {
+                                  bool isImplicit) {
   ASTContext &C = Decl->getASTContext();
   assert(Loc.isValid());
   auto *Repr = new (C) SimpleIdentTypeRepr(Loc, Decl->getName());
   Repr->setValue(Decl);
   auto result = new (C) TypeExpr(TypeLoc(Repr, Type()));
-  result->IsPromotedInstanceRef = isPromotedInstanceRef;
   if (isImplicit)
     result->setImplicit();
   return result;
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -563,11 +563,7 @@ UnqualifiedLookup::UnqualifiedLookup(DeclName Name, DeclContext *DC,
             if (FD->isStatic() && !isMetatypeType)
               continue;
           } else if (isa<EnumElementDecl>(Result)) {
-            auto lookupRes = UnqualifiedLookupResult(MetaBaseDecl, Result);
-            if (!BaseDecl->getType()->is<MetatypeType>()) {
-              lookupRes.IsPromotedInstanceRef = true;
-            }
-            Results.push_back(lookupRes);
+            Results.push_back(UnqualifiedLookupResult(MetaBaseDecl, Result));
             continue;
           }
 
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -2545,24 +2545,6 @@ namespace {
     
   public:
     Expr *visitUnresolvedDotExpr(UnresolvedDotExpr *expr) {
-      if (auto ty = dyn_cast<TypeExpr>(expr->getBase())) {
-        if (ty->IsPromotedInstanceRef) {
-          // An enum element was looked up on an instance. Issue a warning
-          auto enumMetatype = ty->getType()->castTo<AnyMetatypeType>();
-          auto enumType = enumMetatype->getInstanceType()->castTo<EnumType>();
-
-          SmallString<32> enumTypeName;
-          llvm::raw_svector_ostream typeNameStream(enumTypeName);
-          typeNameStream << enumType->getDecl()->getName();
-          typeNameStream << ".";
-
-          TypeChecker &tc = cs.getTypeChecker();
-          tc.diagnose(expr->getLoc(),
-                      diag::could_not_use_enum_element_on_instance,
-                      expr->getName())
-            .fixItInsert(expr->getLoc(), typeNameStream.str());
-        }
-      }
       return applyMemberRefExpr(expr, expr->getBase(), expr->getDotLoc(),
                                 expr->getNameLoc(), expr->isImplicit());
     }
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -551,7 +551,6 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
 
   ResultValues.clear();
   bool AllMemberRefs = true;
-  bool PromotedInstanceRef = false;
   ValueDecl *Base = 0;
   for (auto Result : Lookup) {
     // Track the base for member declarations.
@@ -562,9 +561,6 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
         break;
       }
 
-      if (Result.IsPromotedInstanceRef) {
-        PromotedInstanceRef = true;
-      }
       Base = Result.Base;
       continue;
     }
@@ -576,8 +572,7 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
   if (AllMemberRefs) {
     Expr *BaseExpr;
     if (auto NTD = dyn_cast<NominalTypeDecl>(Base)) {
-      BaseExpr = TypeExpr::createForDecl(Loc, NTD, /*implicit=*/true,
-                                         PromotedInstanceRef);
+      BaseExpr = TypeExpr::createForDecl(Loc, NTD, /*implicit=*/true);
     } else {
       BaseExpr = new (Context) DeclRefExpr(Base, UDRE->getNameLoc(),
                                            /*implicit=*/true);
diff --git a/lib/Sema/TypeCheckNameLookup.cpp b/lib/Sema/TypeCheckNameLookup.cpp
@@ -103,12 +103,7 @@ namespace {
     ///
     /// \param foundInType The type through which we found the
     /// declaration.
-    ///
-    /// \param promotedInstanceRef true if the lookup result to be added was
-    /// actually looked up on an instance but promted to a type to look up an
-    /// enum element
-    void add(ValueDecl *found, ValueDecl *base, Type foundInType,
-             bool promotedInstanceRef = false) {
+    void add(ValueDecl *found, ValueDecl *base, Type foundInType) {
       // If we only want types, AST name lookup should not yield anything else.
       assert(!Options.contains(NameLookupFlags::OnlyTypes) ||
              isa<TypeDecl>(found));
@@ -144,7 +139,7 @@ namespace {
           isa<GenericTypeParamDecl>(found) ||
           (isa<FuncDecl>(found) && cast<FuncDecl>(found)->isOperator())) {
         if (Known.insert({{found, base}, false}).second) {
-          Result.add({found, base, promotedInstanceRef});
+          Result.add({found, base});
           FoundDecls.push_back(found);
         }
         return;
@@ -177,7 +172,7 @@ namespace {
         // default implementations in protocols.
         if (witness && !isa<ProtocolDecl>(witness->getDeclContext())) {
           if (Known.insert({{witness, base}, false}).second) {
-            Result.add({witness, base, promotedInstanceRef});
+            Result.add({witness, base});
             FoundDecls.push_back(witness);
           }
         }
@@ -234,8 +229,7 @@ LookupResult TypeChecker::lookupUnqualified(DeclContext *dc, DeclName name,
       assert(foundInType && "bogus base declaration?");
     }
 
-    builder.add(found.getValueDecl(), found.getBaseDecl(), foundInType,
-                found.IsPromotedInstanceRef);
+    builder.add(found.getValueDecl(), found.getBaseDecl(), foundInType);
   }
   return result;
 }
@@ -572,7 +566,7 @@ void TypeChecker::performTypoCorrection(DeclContext *DC, DeclRefKind refKind,
   entries.filterMaxScoreRange(MaxCallEditDistanceFromBestCandidate);
 
   for (auto &entry : entries)
-    result.add({ entry.Value, nullptr, false });
+    result.add({ entry.Value, nullptr });
 }
 
 static InFlightDiagnostic
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
@@ -72,21 +72,13 @@ extractEnumElement(TypeChecker &TC, DeclContext *DC, SourceLoc UseLoc,
 ///
 /// If there are no enum elements but there are properties, attempts to map
 /// an arbitrary property to an enum element using extractEnumElement.
-///
-/// \param isPromoted If set to anything but the \c nullptr, this will be set to
-///        \c true if the found enum element is referenced as on an instance
-///        but the lookup has been promoted to be on the type instead
-///        This is purely transitional and will be removed when referencing enum
-///        elements on instance members becomes an error
-
 static EnumElementDecl *
 filterForEnumElement(TypeChecker &TC, DeclContext *DC, SourceLoc UseLoc,
-                     LookupResult foundElements, bool *isPromoted = nullptr) {
+                     LookupResult foundElements) {
   EnumElementDecl *foundElement = nullptr;
   VarDecl *foundConstant = nullptr;
 
-  for (LookupResult::Result result : foundElements) {
-    ValueDecl *e = result.Decl;
+  for (ValueDecl *e : foundElements) {
     assert(e);
     if (e->isInvalid()) {
       continue;
@@ -96,9 +88,6 @@ filterForEnumElement(TypeChecker &TC, DeclContext *DC, SourceLoc UseLoc,
       // Ambiguities should be ruled out by parsing.
       assert(!foundElement && "ambiguity in enum case name lookup?!");
       foundElement = oe;
-      if (isPromoted != nullptr) {
-        *isPromoted = result.IsPromotedInstanceRef;
-      }
       continue;
     }
 
@@ -115,20 +104,13 @@ filterForEnumElement(TypeChecker &TC, DeclContext *DC, SourceLoc UseLoc,
 }
 
 /// Find an unqualified enum element.
-///
-/// \param IsPromoted If set to anything but the \c nullptr, this will be set to
-///        \c true if the found enum element is referenced as on an instance
-///        but the lookup has been promoted to be on the type instead
-///        This is purely transitional and will be removed when referencing enum
-///        elements on instance members becomes an error
 static EnumElementDecl *
 lookupUnqualifiedEnumMemberElement(TypeChecker &TC, DeclContext *DC,
-                                   Identifier name, SourceLoc UseLoc,
-                                   bool *IsPromoted = nullptr) {
+                                   Identifier name, SourceLoc UseLoc) {
   auto lookupOptions = defaultUnqualifiedLookupOptions;
   lookupOptions |= NameLookupFlags::KnownPrivate;
   auto lookup = TC.lookupUnqualified(DC, name, SourceLoc(), lookupOptions);
-  return filterForEnumElement(TC, DC, UseLoc, lookup, IsPromoted);
+  return filterForEnumElement(TC, DC, UseLoc, lookup);
 }
 
 /// Find an enum element in an enum type.
@@ -502,22 +484,10 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     // rdar://20879992 is addressed.
     //
     // Try looking up an enum element in context.
-
-    // Check if the enum element was actually accessed on an instance and was
-    // promoted to be looked up on a type. If so, provide a warning
-    bool isPromotedInstance = false;
-
     if (EnumElementDecl *referencedElement
         = lookupUnqualifiedEnumMemberElement(TC, DC,
                                              ude->getName().getBaseName(),
-                                             ude->getLoc(),
-                                             &isPromotedInstance)) {
-      if (isPromotedInstance) {
-        TC.diagnose(ude->getLoc(), diag::could_not_use_enum_element_on_instance,
-                                ude->getName())
-          .fixItInsert(ude->getLoc(), ".");
-      }
-
+                                             ude->getLoc())) {
       auto *enumDecl = referencedElement->getParentEnum();
       auto enumTy = enumDecl->getDeclaredTypeInContext();
       TypeLoc loc = TypeLoc::withoutLoc(enumTy);
@@ -600,21 +570,9 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     // If we had a single component, try looking up an enum element in context.
     if (auto compId = dyn_cast<ComponentIdentTypeRepr>(repr)) {
       // Try looking up an enum element in context.
-
-      // Check if the enum element was actually accessed on an instance and was
-      // promoted to be looked up on a type. If so, provide a warning
-      bool isPromoted = false;
       EnumElementDecl *referencedElement
         = lookupUnqualifiedEnumMemberElement(TC, DC, compId->getIdentifier(),
-                                             repr->getLoc(), &isPromoted);
-
-      if (isPromoted) {
-        TC.diagnose(compId->getLoc(),
-                    diag::could_not_use_enum_element_on_instance,
-                    compId->getIdentifier())
-          .fixItInsert(compId->getLoc(), ".");
-      }
-
+                                             repr->getLoc());
       
       if (!referencedElement)
         return nullptr;
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -63,13 +63,6 @@ class LookupResult {
     /// The base declaration through which we found the declaration.
     ValueDecl *Base;
 
-    /// Whether this should actually reference an instance but has been promoted
-    /// to a type reference to access an enum element
-    ///
-    /// This is purely transitional and will be removed when referencing enum
-    /// elements on instance members becomes an error
-    bool IsPromotedInstanceRef;
-
     operator ValueDecl*() const { return Decl; }
     ValueDecl *operator->() const { return Decl; }
   };
diff --git a/test/Parse/enum.swift b/test/Parse/enum.swift
@@ -433,92 +433,3 @@ enum RawValueBTest: Double, RawValueB {
 enum foo : String {
   case bar = nil // expected-error {{cannot convert nil to raw type 'String'}}
 }
-
-// Static member lookup from instance methods
-
-struct EmptyStruct {}
-
-enum EnumWithStaticMember {
-  static let staticVar = EmptyStruct()
-
-  func foo() {
-    let _ = staticVar // expected-error {{static member 'staticVar' cannot be used on instance of type 'EnumWithStaticMember'}}
-  }
-}
-
-// SE-0036:
-
-struct SE0036_Auxiliary {}
-
-enum SE0036 {
-  case A
-  case B(SE0036_Auxiliary)
-
-  static func staticReference() {
-    _ = A
-    _ = SE0036.A
-  }
-
-  func staticReferencInInstanceMethod() {
-    _ = A // expected-warning {{referencing enum element 'A' as instance member is deprecated and will be removed in Swift 3}} {{9-9=SE0036.}}
-    _ = SE0036.A
-  }
-
-  static func staticReferencInSwitchInStaticMethod() {
-    switch SE0036.A {
-    case A: break
-    case B(_): break
-    }
-  }
-
-  func staticReferencInSwitchInInstanceMethod() {
-    switch self {
-    case A: break // expected-warning {{referencing enum element 'A' as instance member is deprecated and will be removed in Swift 3}} {{10-10=.}}
-    case B(_): break // expected-warning {{referencing enum element 'B' as instance member is deprecated and will be removed in Swift 3}} {{10-10=.}}
-    }
-  }
-
-  func explicitReferencInSwitch() {
-    switch SE0036.A {
-    case SE0036.A: break
-    case SE0036.B(_): break
-    }
-  }
-
-  func dotReferencInSwitchInInstanceMethod() {
-    switch self {
-    case .A: break
-    case .B(_): break
-    }
-  }
-
-  static func dotReferencInSwitchInStaticMethod() {
-    switch SE0036.A {
-    case .A: break
-    case .B(_): break
-    }
-  }
-
-  init() {
-    self = .A
-    self = A // expected-warning {{referencing enum element 'A' as instance member is deprecated and will be removed in Swift 3}} {{12-12=SE0036.}}
-    self = SE0036.A
-    self = .B(SE0036_Auxiliary())
-    self = B(SE0036_Auxiliary()) // expected-warning {{referencing enum element 'B' as instance member is deprecated and will be removed in Swift 3}} {{12-12=SE0036.}}
-    self = SE0036.B(SE0036_Auxiliary())
-  }
-}
-
-enum SE0036_Generic<T> {
-  case A(x: T)
-
-  func foo() {
-    switch self {
-    case A(_): break // expected-warning {{referencing enum element 'A' as instance member is deprecated and will be removed in Swift 3}} {{10-10=.}}
-    }
-
-    switch self {
-    case SE0036_Generic.A(let a): print(a)
-    }
-  }
-}
