Merge pull request swiftlang#21162 from slavapestov/random-crap

slavapestov · web-flow · commit 47b7d4389d60 · 2018-12-10T13:28:57.000-05:00
A grab-bag of cleanups
diff --git a/lib/IRGen/GenEnum.cpp b/lib/IRGen/GenEnum.cpp
diff --git a/lib/IRGen/GenFunc.cpp b/lib/IRGen/GenFunc.cpp
@@ -642,11 +642,13 @@ static bool isABIIgnoredParameterWithoutStorage(IRGenModule &IGM,
                                                 CanSILFunctionType substType,
                                                 unsigned paramIdx) {
   auto param = substType->getParameters()[paramIdx];
+  if (param.isFormalIndirect())
+    return false;
+
   SILType argType = IGM.silConv.getSILType(param);
-  auto argLoweringTy = getArgumentLoweringType(argType.getASTType(), param);
-  auto &ti = IGF.getTypeInfoForLowered(argLoweringTy);
+  auto &ti = IGF.getTypeInfoForLowered(argType.getASTType());
   // Empty values don't matter.
-  return ti.getSchema().empty() && !param.isFormalIndirect();
+  return ti.getSchema().empty();
 }
 
 /// Find the parameter index for the one (assuming there was only one) partially
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
@@ -2799,6 +2799,8 @@ void NecessaryBindings::save(IRGenFunction &IGF, Address buffer) const {
 }
 
 void NecessaryBindings::addTypeMetadata(CanType type) {
+  assert(!isa<InOutType>(type));
+
   // Bindings are only necessary at all if the type is dependent.
   if (!type->hasArchetype()) return;
 
@@ -2819,10 +2821,6 @@ void NecessaryBindings::addTypeMetadata(CanType type) {
     addTypeMetadata(fn.getResult());
     return;
   }
-  if (auto inout = dyn_cast<InOutType>(type)) {
-    addTypeMetadata(inout.getObjectType());
-    return;
-  }
   if (auto metatype = dyn_cast<MetatypeType>(type)) {
     addTypeMetadata(metatype.getInstanceType());
     return;
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -4090,7 +4090,7 @@ namespace {
         method = func;
       } else if (auto var = dyn_cast<VarDecl>(foundDecl)) {
         // Properties.
-        maybeAddAccessorsToStorage(tc, var);
+        maybeAddAccessorsToStorage(var);
 
         // If this isn't a property on a type, complain.
         if (!var->getDeclContext()->isTypeContext()) {
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -620,10 +620,8 @@ static bool checkConformanceToNSCopying(ASTContext &ctx, VarDecl *var,
   auto dc = var->getDeclContext();
   auto proto = getNSCopyingProtocol(ctx, dc);
 
-  // FIXME: Remove this usage of TypeChecker
-  auto &TC = *(TypeChecker *) ctx.getLazyResolver();
-  if (!proto || !TC.conformsToProtocol(type, proto, dc, None)) {
-    TC.diagnose(var->getLoc(), diag::nscopying_doesnt_conform);
+  if (!proto || !TypeChecker::conformsToProtocol(type, proto, dc, None)) {
+    ctx.Diags.diagnose(var->getLoc(), diag::nscopying_doesnt_conform);
     return true;
   }
   return false;
@@ -1337,7 +1335,9 @@ static void synthesizeLazySetterBody(AbstractFunctionDecl *fn, void *context) {
                                          underlyingStorage, ctx);
 }
 
-void TypeChecker::completeLazyVarImplementation(VarDecl *VD) {
+void swift::completeLazyVarImplementation(VarDecl *VD) {
+  auto &Context = VD->getASTContext();
+
   assert(VD->getAttrs().hasAttribute<LazyAttr>());
   assert(VD->getReadImpl() == ReadImplKind::Get);
   assert(VD->getWriteImpl() == WriteImplKind::Set);
@@ -1406,13 +1406,13 @@ static bool wouldBeCircularSynthesis(AbstractStorageDecl *storage,
 void swift::triggerAccessorSynthesis(TypeChecker &TC,
                                      AbstractStorageDecl *storage) {
   auto VD = dyn_cast<VarDecl>(storage);
-  maybeAddAccessorsToStorage(TC, storage);
+  maybeAddAccessorsToStorage(storage);
 
   // Synthesize accessors for lazy, all checking already been performed.
   bool lazy = false;
   if (VD && VD->getAttrs().hasAttribute<LazyAttr>() && !VD->isStatic() &&
       !VD->getGetter()->hasBody()) {
-    TC.completeLazyVarImplementation(VD);
+    completeLazyVarImplementation(VD);
     lazy = true;
   }
 
@@ -1466,11 +1466,12 @@ static void maybeAddAccessorsToLazyVariable(VarDecl *var, ASTContext &ctx) {
 /// Note that the parser synthesizes accessors in some cases:
 ///   - it synthesizes a getter and setter for an observing property
 ///   - it synthesizes a setter for get+mutableAddress
-void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
-                                       AbstractStorageDecl *storage) {
+void swift::maybeAddAccessorsToStorage(AbstractStorageDecl *storage) {
+  auto &ctx = storage->getASTContext();
+
   // Lazy properties require special handling.
   if (storage->getAttrs().hasAttribute<LazyAttr>()) {
-    maybeAddAccessorsToLazyVariable(cast<VarDecl>(storage), TC.Context);
+    maybeAddAccessorsToLazyVariable(cast<VarDecl>(storage), ctx);
     return;
   }
 
@@ -1487,7 +1488,7 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
   if (!dc->isTypeContext()) {
     // dynamic globals need accessors.
     if (dc->isModuleScopeContext() && storage->isNativeDynamic()) {
-      addTrivialAccessorsToStorage(storage, TC.Context);
+      addTrivialAccessorsToStorage(storage, ctx);
       return;
     }
     // Fixed-layout global variables don't get accessors.
@@ -1502,12 +1503,13 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
       auto var = cast<VarDecl>(storage);
 
       if (var->isLet()) {
-        TC.diagnose(var->getLoc(),
-                   diag::protocol_property_must_be_computed_var)
+        ctx.Diags.diagnose(var->getLoc(),
+                           diag::protocol_property_must_be_computed_var)
           .fixItReplace(var->getParentPatternBinding()->getLoc(), "var")
           .fixItInsertAfter(var->getTypeLoc().getLoc(), " { get }");
       } else {
-        auto diag = TC.diagnose(var->getLoc(), diag::protocol_property_must_be_computed);
+        auto diag = ctx.Diags.diagnose(var->getLoc(),
+                                       diag::protocol_property_must_be_computed);
         auto braces = var->getBracesRange();
 
         if (braces.isValid())
@@ -1517,14 +1519,14 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
       }
     }
 
-    setProtocolStorageImpl(storage, TC.Context);
+    setProtocolStorageImpl(storage, ctx);
     return;
 
   // NSManaged properties on classes require special handling.
   } else if (dc->getSelfClassDecl()) {
     auto var = dyn_cast<VarDecl>(storage);
     if (var && var->getAttrs().hasAttribute<NSManagedAttr>()) {
-      convertNSManagedStoredVarToComputed(var, TC.Context);
+      convertNSManagedStoredVarToComputed(var, ctx);
       return;
     }
 
@@ -1539,13 +1541,13 @@ void swift::maybeAddAccessorsToStorage(TypeChecker &TC,
   if (auto sourceFile = dc->getParentSourceFile())
     if (sourceFile->Kind == SourceFileKind::SIL) {
       if (storage->getGetter()) {
-        addExpectedOpaqueAccessorsToStorage(storage, TC.Context);
+        addExpectedOpaqueAccessorsToStorage(storage, ctx);
       }
       return;
     }
 
   // Everything else gets mandatory accessors.
-  addTrivialAccessorsToStorage(storage, TC.Context);
+  addTrivialAccessorsToStorage(storage, ctx);
 }
 
 static void synthesizeGetterBody(AccessorDecl *getter,
diff --git a/lib/Sema/CodeSynthesis.h b/lib/Sema/CodeSynthesis.h
@@ -49,10 +49,14 @@ void makeFinal(ASTContext &ctx, ValueDecl *D);
 bool checkOverrides(ValueDecl *decl);
 
 // These are implemented in CodeSynthesis.cpp.
-void maybeAddAccessorsToStorage(TypeChecker &TC, AbstractStorageDecl *storage);
+void maybeAddAccessorsToStorage(AbstractStorageDecl *storage);
 
 void triggerAccessorSynthesis(TypeChecker &TC, AbstractStorageDecl *storage);
 
+/// Provide storage and accessor implementations for the given property,
+/// which must be lazy.
+void completeLazyVarImplementation(VarDecl *lazyVar);
+
 /// Describes the kind of implicit constructor that will be
 /// generated.
 enum class ImplicitConstructorKind {
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2018,7 +2018,7 @@ static void finalizeAbstractStorageDecl(TypeChecker &TC,
   TC.validateDecl(storage);
 
   // Add any mandatory accessors now.
-  maybeAddAccessorsToStorage(TC, storage);
+  maybeAddAccessorsToStorage(storage);
 
   for (auto accessor : storage->getAllAccessors()) {
     // Are there accessors we can safely ignore here, like maybe observers?
@@ -2124,7 +2124,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     TC.validateDecl(VD);
 
     // Set up accessors.
-    maybeAddAccessorsToStorage(TC, VD);
+    maybeAddAccessorsToStorage(VD);
 
     // WARNING: Anything you put in this function will only be run when the
     // VarDecl is fully type-checked within its own file. It will NOT be run
@@ -4292,7 +4292,7 @@ void TypeChecker::requestMemberLayout(ValueDecl *member) {
     // because if they never get validated at all then conformance checkers
     // will complain about selector mismatches.
     if (storage->isObjC()) {
-      maybeAddAccessorsToStorage(*this, storage);
+      maybeAddAccessorsToStorage(storage);
       for (auto accessor : storage->getAllAccessors()) {
         requestMemberLayout(accessor);
       }
@@ -4345,7 +4345,7 @@ static void finalizeType(TypeChecker &TC, NominalTypeDecl *nominal) {
     if (prop->getAttrs().hasAttribute<LazyAttr>() && !prop->isStatic() &&
         (!prop->getGetter() || !prop->getGetter()->hasBody())) {
       finalizeAbstractStorageDecl(TC, prop);
-      TC.completeLazyVarImplementation(prop);
+      completeLazyVarImplementation(prop);
     }
   }
 
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
@@ -859,11 +859,8 @@ bool OverrideMatcher::checkOverride(ValueDecl *baseDecl,
       auto matchASD = cast<AbstractStorageDecl>(baseDecl);
       if (matchASD->isSetterAccessibleFrom(dc)) {
         // Match sure we've created the setter.
-        if (!matchASD->getSetter()) {
-          maybeAddAccessorsToStorage(
-                           *static_cast<TypeChecker *>(ctx.getLazyResolver()),
-                           matchASD);
-        }
+        if (!matchASD->getSetter())
+          maybeAddAccessorsToStorage(matchASD);
 
         auto matchSetterAccessScope = matchASD->getSetter()
           ->getFormalAccessScope(dc);
@@ -1759,13 +1756,9 @@ OverriddenDeclsRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
 
     // Check the various overridden storage declarations.
     SmallVector<OverrideMatch, 2> matches;
-    ASTContext &ctx = decl->getASTContext();
     for (auto overridden : overridingASD->getOverriddenDecls()) {
       auto baseASD = cast<AbstractStorageDecl>(overridden);
-      if (auto lazyResolver = ctx.getLazyResolver()) {
-        maybeAddAccessorsToStorage(*static_cast<TypeChecker *>(lazyResolver),
-                                   baseASD);
-      }
+      maybeAddAccessorsToStorage(baseASD);
 
       auto kind = accessor->getAccessorKind();
 
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -1266,10 +1266,6 @@ class TypeChecker final : public LazyResolver {
   void synthesizeWitnessAccessorsForStorage(AbstractStorageDecl *requirement,
                                             AbstractStorageDecl *storage);
 
-  /// Provide storage and accessor implementations for the given property,
-  /// which must be lazy.
-  void completeLazyVarImplementation(VarDecl *lazyVar);
-
   /// Pre-check the expression, validating any types that occur in the
   /// expression and folding sequence expressions.
   bool preCheckExpression(Expr *&expr, DeclContext *dc);
diff --git a/validation-test/compiler_crashers_2_fixed/0183-sr8998.swift b/validation-test/compiler_crashers_2_fixed/0183-sr8998.swift
@@ -0,0 +1,15 @@
+// RUN: not %target-swift-frontend -emit-ir %s
+
+protocol P {
+    associatedtype A: Q where A.B == Self
+}
+
+protocol Q {
+    associatedtype B: P where B.A == Self
+}
+
+struct S1<T>: P where T: Q { }
+
+struct S2: Q {
+    typealias B = S1<S2>
+}
diff --git a/validation-test/compiler_crashers_2_fixed/0184-8764.swift b/validation-test/compiler_crashers_2_fixed/0184-8764.swift
@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend -emit-ir %s
+
+@discardableResult public func applyWrapped<T, U>(function: Optional<(T) -> U>, to value: Optional<T>) -> Optional<U> {
+    switch (function, value) {
+    case (let .some(f), let .some(v)):
+        return .some(f(v))
+    case (.none, _):
+        return .none
+    case (_, .none):
+        return .none
+    }
+}
