Sema: Remove unnecessary circularity breaks

slavapestov · slavapestov · commit 6828a12416ba · 2019-10-03T17:11:45.000-04:00
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -1209,6 +1209,7 @@ class UnderlyingTypeRequest :
   bool isCached() const { return true; }
   Optional<Type> getCachedResult() const;
   void cacheResult(Type value) const;
+  void diagnoseCycle(DiagnosticEngine &diags) const;
 };
 
 class OperatorPrecedenceGroupRequest
diff --git a/lib/AST/TypeCheckRequests.cpp b/lib/AST/TypeCheckRequests.cpp
@@ -12,6 +12,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsCommon.h"
+#include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/PropertyWrappers.h"
@@ -855,6 +856,13 @@ void UnderlyingTypeRequest::cacheResult(Type value) const {
   typeAlias->UnderlyingTy.setType(value);
 }
 
+void UnderlyingTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
+  auto aliasDecl = std::get<0>(getStorage());
+  diags.diagnose(aliasDecl, diag::recursive_decl_reference,
+                 aliasDecl->getDescriptiveKind(),
+                 aliasDecl->getName());
+}
+
 //----------------------------------------------------------------------------//
 // EnumRawValuesRequest computation.
 //----------------------------------------------------------------------------//
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -3901,23 +3901,17 @@ void TypeChecker::validateDecl(ValueDecl *D) {
   case DeclKind::AssociatedType: {
     auto assocType = cast<AssociatedTypeDecl>(D);
 
-    DeclValidationRAII IBV(assocType);
-
-    // Finally, set the interface type.
-    if (!assocType->hasInterfaceType())
-      assocType->computeType();
+    assocType->computeType();
+    assocType->setValidationToChecked();
 
     break;
   }
 
   case DeclKind::TypeAlias: {
     auto typeAlias = cast<TypeAliasDecl>(D);
 
-    DeclValidationRAII IBV(typeAlias);
-
-    // Finally, set the interface type.
-    if (!typeAlias->hasInterfaceType())
-      typeAlias->computeType();
+    typeAlias->computeType();
+    typeAlias->setValidationToChecked();
     
     break;
   }
@@ -3953,8 +3947,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
 
   case DeclKind::Protocol: {
     auto proto = cast<ProtocolDecl>(D);
-    if (!proto->hasInterfaceType())
-      proto->computeType();
+    proto->computeType();
     proto->setValidationToChecked();
 
     break;
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -214,22 +214,16 @@ Type TypeResolution::resolveDependentMemberType(
     ref->setValue(singleType, nullptr);
   }
 
+  auto *concrete = ref->getBoundDecl();
+
   // If the nested type has been resolved to an associated type, use it.
-  if (auto assocType = dyn_cast<AssociatedTypeDecl>(ref->getBoundDecl())) {
+  if (auto assocType = dyn_cast<AssociatedTypeDecl>(concrete)) {
     return DependentMemberType::get(baseTy, assocType);
   }
 
   // Otherwise, the nested type comes from a concrete type,
   // or it's a typealias declared in protocol or protocol extension.
   // Substitute the base type into it.
-  auto concrete = ref->getBoundDecl();
-  if (!concrete->getInterfaceType()) {
-    ctx.Diags.diagnose(ref->getIdLoc(), diag::recursive_decl_reference,
-                       concrete->getDescriptiveKind(), concrete->getName());
-    concrete->diagnose(diag::kind_declared_here,
-                       DescriptiveDeclKind::Type);
-    return ErrorType::get(ctx);
-  }
 
   // Make sure that base type didn't get replaced along the way.
   assert(baseTy->isTypeParameter());
@@ -713,16 +707,6 @@ Type TypeChecker::applyGenericArguments(Type type,
     }  
   }
 
-  // Cannot extend a bound generic type.
-  if (options.is(TypeResolverContext::ExtensionBinding)) {
-    if (!options.contains(TypeResolutionFlags::SilenceErrors)) {
-      diags.diagnose(loc, diag::extension_specialization,
-               genericDecl->getName())
-        .highlight(generic->getSourceRange());
-    }
-    return ErrorType::get(ctx);
-  }
-
   // FIXME: More principled handling of circularity.
   if (!genericDecl->getGenericSignature()) {
     diags.diagnose(loc, diag::recursive_decl_reference,
@@ -934,33 +918,6 @@ static Type resolveTypeDecl(TypeDecl *typeDecl, SourceLoc loc,
                             DeclContext *foundDC, TypeResolution resolution,
                             GenericIdentTypeRepr *generic,
                             TypeResolutionOptions options) {
-  auto fromDC = resolution.getDeclContext();
-  assert(fromDC && "No declaration context for type resolution?");
-
-  ASTContext &ctx = typeDecl->getASTContext();
-  auto &diags = ctx.Diags;
-
-  // Hack: Don't validate nested typealiases if we only need the structural
-  // type.
-  auto prevalidatingAlias = [](TypeDecl *typeDecl, TypeResolution res) {
-    return isa<TypeAliasDecl>(typeDecl)
-        && !typeDecl->hasInterfaceType()
-        && typeDecl->getDeclContext()->isTypeContext()
-        && res.getStage() == TypeResolutionStage::Structural;
-  };
-
-  // Don't validate nominal type declarations during extension binding.
-  if ((!options.is(TypeResolverContext::ExtensionBinding) ||
-       !isa<NominalTypeDecl>(typeDecl)) &&
-      !prevalidatingAlias(typeDecl, resolution)) {
-    // If we were not able to validate recursively, bail out.
-    if (!typeDecl->getInterfaceType()) {
-      diags.diagnose(loc, diag::recursive_decl_reference,
-                     typeDecl->getDescriptiveKind(), typeDecl->getName());
-      typeDecl->diagnose(diag::kind_declared_here, DescriptiveDeclKind::Type);
-      return ErrorType::get(ctx);
-    }
-  }
 
   // Resolve the type declaration to a specific type. How this occurs
   // depends on the current context and where the type was found.
@@ -971,11 +928,13 @@ static Type resolveTypeDecl(TypeDecl *typeDecl, SourceLoc loc,
       !options.is(TypeResolverContext::TypeAliasDecl) &&
       !options.contains(TypeResolutionFlags::AllowUnboundGenerics)) {
     diagnoseUnboundGenericType(type, loc);
-    return ErrorType::get(ctx);
+    return ErrorType::get(typeDecl->getASTContext());
   }
 
   if (type->hasError() && foundDC &&
       (isa<AssociatedTypeDecl>(typeDecl) || isa<TypeAliasDecl>(typeDecl))) {
+    auto fromDC = resolution.getDeclContext();
+    assert(fromDC && "No declaration context for type resolution?");
     maybeDiagnoseBadConformanceRef(fromDC, foundDC->getDeclaredInterfaceType(),
                                    loc, typeDecl);
   }
@@ -3477,8 +3436,6 @@ class UnsupportedProtocolVisitor
         T->setInvalid();
       }
     } else if (auto *alias = dyn_cast_or_null<TypeAliasDecl>(comp->getBoundDecl())) {
-      if (!alias->hasInterfaceType())
-        return;
       auto type = Type(alias->getDeclaredInterfaceType()->getDesugaredType());
       type.findIf([&](Type type) -> bool {
         if (T->isInvalid())
diff --git a/test/CircularReferences/global_typealias.swift b/test/CircularReferences/global_typealias.swift
@@ -1,6 +1,6 @@
 // RUN: %target-typecheck-verify-swift
 
-typealias A = B // expected-note{{type declared here}}
-typealias C = D
-typealias D = (A, Int) // expected-error{{type alias 'A' references itself}}
-typealias B = C
+typealias A = B // expected-error {{type alias 'A' references itself}}
+typealias C = D // expected-note {{through reference here}}
+typealias D = (A, Int) // expected-note {{through reference here}}
+typealias B = C // expected-note {{through reference here}}
diff --git a/test/Sema/circular_decl_checking.swift b/test/Sema/circular_decl_checking.swift
@@ -66,7 +66,6 @@ class X {
 struct SomeStruct<A> {
   typealias A = A // this is OK now -- the underlying type is the generic parameter 'A'
   typealias B = B // expected-error {{type alias 'B' references itself}}
-  // expected-note@-1 {{type declared here}}
 }
 
 // <rdar://problem/27680407> Infinite recursion when using fully-qualified associatedtype name that has not been defined with typealias
diff --git a/test/Sema/diag_typealias.swift b/test/Sema/diag_typealias.swift
@@ -3,4 +3,3 @@
 struct S {}
 
 typealias S = S // expected-error {{type alias 'S' references itself}}
-// expected-note@-1{{type declared here}}
diff --git a/test/decl/enum/Inputs/objc_enum_multi_file_helper.swift b/test/decl/enum/Inputs/objc_enum_multi_file_helper.swift
@@ -1,6 +1,6 @@
 func useEnum(_ x: TheEnum) {
   switch x {
-  case A:
+  case .A:
     print("a!")
   default:
     break
diff --git a/test/decl/enum/objc_enum_multi_file.swift b/test/decl/enum/objc_enum_multi_file.swift
@@ -1,8 +1,8 @@
-// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -typecheck -D NO_RAW_TYPE 2>&1 | %FileCheck -check-prefix=NO_RAW_TYPE %s
-// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -typecheck -D BAD_RAW_TYPE 2>&1 | %FileCheck -check-prefix=BAD_RAW_TYPE %s
-// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -typecheck -D NON_INT_RAW_TYPE 2>&1 | %FileCheck -check-prefix=NON_INT_RAW_TYPE %s
-// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -typecheck -D NO_CASES 2>&1 | %FileCheck -check-prefix=NO_CASES %s
-// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -typecheck -D DUPLICATE_CASES 2>&1 | %FileCheck -check-prefix=DUPLICATE_CASES %s
+// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -emit-ir -D NO_RAW_TYPE 2>&1 | %FileCheck -check-prefix=NO_RAW_TYPE %s
+// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -emit-ir -D BAD_RAW_TYPE 2>&1 | %FileCheck -check-prefix=BAD_RAW_TYPE %s
+// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -emit-ir -D NON_INT_RAW_TYPE 2>&1 | %FileCheck -check-prefix=NON_INT_RAW_TYPE %s
+// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -emit-ir -D NO_CASES 2>&1 | %FileCheck -check-prefix=NO_CASES %s
+// RUN: not %target-swift-frontend -module-name main %s -primary-file %S/Inputs/objc_enum_multi_file_helper.swift -emit-ir -D DUPLICATE_CASES 2>&1 | %FileCheck -check-prefix=DUPLICATE_CASES %s
 // Note that the *other* file is the primary file in this test!
 
 #if NO_RAW_TYPE
diff --git a/test/decl/init/basic_init.swift b/test/decl/init/basic_init.swift
@@ -11,7 +11,6 @@ class C {
 }
 
 typealias t = t // expected-error {{type alias 't' references itself}}
-// expected-note@-1{{type declared here}}
 
 extension Foo {
   convenience init() {} // expected-error{{invalid redeclaration of synthesized 'init()'}}
diff --git a/test/decl/typealias/generic.swift b/test/decl/typealias/generic.swift
@@ -303,9 +303,9 @@ func takesSugaredType2(m: GenericClass<Int>.TA<Float>) {
 extension A {}
 
 extension A<T> {}  // expected-error {{generic type 'A' specialized with too few type parameters (got 1, but expected 2)}}
-extension A<Float,Int> {}  // expected-error {{constrained extension must be declared on the unspecialized generic type 'A' with constraints specified by a 'where' clause}}
-extension C<T> {}  // expected-error {{constrained extension must be declared on the unspecialized generic type 'C' with constraints specified by a 'where' clause}}
-extension C<Int> {}  // expected-error {{constrained extension must be declared on the unspecialized generic type 'C' with constraints specified by a 'where' clause}}
+extension A<Float,Int> {}  // expected-error {{constrained extension must be declared on the unspecialized generic type 'MyType' with constraints specified by a 'where' clause}}
+extension C<T> {}  // expected-error {{use of undeclared type 'T'}}
+extension C<Int> {}  // expected-error {{constrained extension must be declared on the unspecialized generic type 'MyType' with constraints specified by a 'where' clause}}
 
 
 protocol ErrorQ {
diff --git a/test/decl/typealias/protocol.swift b/test/decl/typealias/protocol.swift
@@ -145,14 +145,12 @@ protocol P3 {
 // Test for not crashing on recursive aliases
 protocol Circular {
   typealias Y = Self.Y // expected-error {{type alias 'Y' references itself}}
-  // expected-note@-1 {{type declared here}}
 
   typealias Y2 = Y2 // expected-error {{type alias 'Y2' references itself}}
-  // expected-note@-1 {{type declared here}}
 
-  typealias Y3 = Y4 // expected-note {{type declared here}}
+  typealias Y3 = Y4 // expected-error {{type alias 'Y3' references itself}}
 
-  typealias Y4 = Y3 // expected-error {{type alias 'Y3' references itself}}
+  typealias Y4 = Y3 // expected-note {{through reference here}}
 }
 
 // Qualified and unqualified references to protocol typealiases from concrete type

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,6 @@ class X {`
`66`	`66`	`struct SomeStruct<A> {`
`67`	`67`	`typealias A = A // this is OK now -- the underlying type is the generic parameter 'A'`
`68`	`68`	`typealias B = B // expected-error {{type alias 'B' references itself}}`
`69`		`- // expected-note@-1 {{type declared here}}`
`70`	`69`	`}`
`71`	`70`
`72`	`71`	`// <rdar://problem/27680407> Infinite recursion when using fully-qualified associatedtype name that has not been defined with typealias`
Original file line number	Diff line number	Diff line change
`@@ -3,4 +3,3 @@`
`3`	`3`	`struct S {}`
`4`	`4`
`5`	`5`	`typealias S = S // expected-error {{type alias 'S' references itself}}`
`6`		`-// expected-note@-1{{type declared here}}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,6 @@ class C {`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`typealias t = t // expected-error {{type alias 't' references itself}}`
`14`		`-// expected-note@-1{{type declared here}}`
`15`	`14`
`16`	`15`	`extension Foo {`
`17`	`16`	`convenience init() {} // expected-error{{invalid redeclaration of synthesized 'init()'}}`