[Type checker] Stop (ab)using TypeChecker::Diags to suppress diagnostics.

Take away the type checker constructor that allows one to provide a
diagnostic engine different from the one associated with the ASTContext. It
doesn’t actually work to suppress diagnostics. Switch all clients over to
the constructor that takes only an ASTContext.

Introduce the DiagnosticSuppression RAII class so clients that want to
suppress diagnostics can suppress *all* diagnostics. Use it where we
were previously suppressing diagnostics.

Author: DougGregor

include/swift/AST/DiagnosticSuppression.h

@@ -0,0 +1,43 @@
+//===--- InstrumenterSupport.cpp - Instrumenter Support -------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the supporting functions for writing instrumenters of
+//  the Swift AST.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_DIAGNOSTIC_SUPPRESSION_H
+#define SWIFT_AST_DIAGNOSTIC_SUPPRESSION_H
+
+#include <vector>
+
+namespace swift {
+
+class DiagnosticConsumer;
+class DiagnosticEngine;
+
+/// RAII class that suppresses diagnostics by temporarily disabling all of
+/// the diagnostic consumers.
+class DiagnosticSuppression {
+  DiagnosticEngine &diags;
+  std::vector<DiagnosticConsumer *> consumers;
+
+  DiagnosticSuppression(const DiagnosticSuppression &) = delete;
+  DiagnosticSuppression &operator=(const DiagnosticSuppression &) = delete;
+
+public:
+  explicit DiagnosticSuppression(DiagnosticEngine &diags);
+  ~DiagnosticSuppression();
+};
+
+}
+#endif /* SWIFT_AST_DIAGNOSTIC_SUPPRESSION_H */

lib/AST/DiagnosticEngine.cpp

@@ -19,6 +19,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/DiagnosticSuppression.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/PrintOptions.h"
@@ -831,3 +832,14 @@ void DiagnosticEngine::emitDiagnostic(const Diagnostic &diagnostic) {
 const char *DiagnosticEngine::diagnosticStringFor(const DiagID id) {
   return diagnosticStrings[(unsigned)id];
 }
+
+DiagnosticSuppression::DiagnosticSuppression(DiagnosticEngine &diags)
+  : diags(diags)
+{
+  consumers = diags.takeConsumers();
+}
+
+DiagnosticSuppression::~DiagnosticSuppression() {
+  for (auto consumer : consumers)
+    diags.addConsumer(*consumer);
+}

lib/Sema/InstrumenterSupport.cpp

@@ -16,6 +16,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "InstrumenterSupport.h"
+#include "swift/AST/DiagnosticSuppression.h"
 
 using namespace swift;
 using namespace swift::instrumenter_support;
@@ -77,10 +78,10 @@ void InstrumenterBase::anchor() {}
 
 bool InstrumenterBase::doTypeCheckImpl(ASTContext &Ctx, DeclContext *DC,
                                        Expr * &parsedExpr) {
-  DiagnosticEngine diags(Ctx.SourceMgr);
-  ErrorGatherer errorGatherer(diags);
+  DiagnosticSuppression suppression(Ctx.Diags);
+  ErrorGatherer errorGatherer(Ctx.Diags);
 
-  TypeChecker TC(Ctx, diags);
+  TypeChecker TC(Ctx);
 
   TC.typeCheckExpression(parsedExpr, DC);
 

lib/Sema/TypeChecker.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/Attr.h"
+#include "swift/AST/DiagnosticSuppression.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Initializer.h"
@@ -49,8 +50,8 @@
 
 using namespace swift;
 
-TypeChecker::TypeChecker(ASTContext &Ctx, DiagnosticEngine &Diags)
-  : Context(Ctx), Diags(Diags)
+TypeChecker::TypeChecker(ASTContext &Ctx)
+  : Context(Ctx), Diags(Ctx.Diags)
 {
   auto clangImporter =
     static_cast<ClangImporter *>(Context.getClangModuleLoader());
@@ -750,13 +751,10 @@ bool swift::performTypeLocChecking(ASTContext &Ctx, TypeLoc &T,
     options |= TypeResolutionFlags::SILType;
 
   auto resolution = TypeResolution::forContextual(DC, GenericEnv);
-  if (ProduceDiagnostics) {
-    return TypeChecker(Ctx).validateType(T, resolution, options);
-  } else {
-    // Set up a diagnostics engine that swallows diagnostics.
-    DiagnosticEngine Diags(Ctx.SourceMgr);
-    return TypeChecker(Ctx, Diags).validateType(T, resolution, options);
-  }
+  Optional<DiagnosticSuppression> suppression;
+  if (!ProduceDiagnostics)
+    suppression.emplace(Ctx.Diags);
+  return TypeChecker(Ctx).validateType(T, resolution, options);
 }
 
 /// Expose TypeChecker's handling of GenericParamList to SIL parsing.
@@ -769,9 +767,8 @@ swift::handleSILGenericParams(ASTContext &Ctx, GenericParamList *genericParams,
 void swift::typeCheckCompletionDecl(Decl *D) {
   auto &Ctx = D->getASTContext();
 
-  // Set up a diagnostics engine that swallows diagnostics.
-  DiagnosticEngine Diags(Ctx.SourceMgr);
-  TypeChecker TC(Ctx, Diags);
+  DiagnosticSuppression suppression(Ctx.Diags);
+  TypeChecker TC(Ctx);
 
   if (auto ext = dyn_cast<ExtensionDecl>(D))
     TC.validateExtension(ext);
@@ -827,15 +824,14 @@ Optional<Type> swift::getTypeOfCompletionContextExpr(
                         CompletionTypeCheckKind kind,
                         Expr *&parsedExpr,
                         ConcreteDeclRef &referencedDecl) {
+  DiagnosticSuppression suppression(Ctx.Diags);
 
   if (Ctx.getLazyResolver()) {
     TypeChecker *TC = static_cast<TypeChecker *>(Ctx.getLazyResolver());
     return ::getTypeOfCompletionContextExpr(*TC, DC, kind, parsedExpr,
                                             referencedDecl);
   } else {
-    // Set up a diagnostics engine that swallows diagnostics.
-    DiagnosticEngine diags(Ctx.SourceMgr);
-    TypeChecker TC(Ctx, diags);
+    TypeChecker TC(Ctx);
     // Try to solve for the actual type of the expression.
     return ::getTypeOfCompletionContextExpr(TC, DC, kind, parsedExpr,
                                             referencedDecl);
@@ -844,29 +840,27 @@ Optional<Type> swift::getTypeOfCompletionContextExpr(
 
 bool swift::typeCheckCompletionSequence(DeclContext *DC, Expr *&parsedExpr) {
   auto &ctx = DC->getASTContext();
+  DiagnosticSuppression suppression(ctx.Diags);
   if (ctx.getLazyResolver()) {
     TypeChecker *TC = static_cast<TypeChecker *>(ctx.getLazyResolver());
     return TC->typeCheckCompletionSequence(parsedExpr, DC);
   } else {
-    // Set up a diagnostics engine that swallows diagnostics.
-    DiagnosticEngine diags(ctx.SourceMgr);
-    TypeChecker TC(ctx, diags);
+    TypeChecker TC(ctx);
     return TC.typeCheckCompletionSequence(parsedExpr, DC);
   }
 }
 
 bool swift::typeCheckExpression(DeclContext *DC, Expr *&parsedExpr) {
   auto &ctx = DC->getASTContext();
+  DiagnosticSuppression suppression(ctx.Diags);
   if (ctx.getLazyResolver()) {
     TypeChecker *TC = static_cast<TypeChecker *>(ctx.getLazyResolver());
     auto resultTy = TC->typeCheckExpression(parsedExpr, DC, TypeLoc(),
                                       ContextualTypePurpose::CTP_Unused,
                                       TypeCheckExprFlags::SuppressDiagnostics);
     return !resultTy;
   } else {
-    // Set up a diagnostics engine that swallows diagnostics.
-    DiagnosticEngine diags(ctx.SourceMgr);
-    TypeChecker TC(ctx, diags);
+    TypeChecker TC(ctx);
     auto resultTy = TC.typeCheckExpression(parsedExpr, DC, TypeLoc(),
                                       ContextualTypePurpose::CTP_Unused,
                                       TypeCheckExprFlags::SuppressDiagnostics);
@@ -877,35 +871,26 @@ bool swift::typeCheckExpression(DeclContext *DC, Expr *&parsedExpr) {
 bool swift::typeCheckAbstractFunctionBodyUntil(AbstractFunctionDecl *AFD,
                                                SourceLoc EndTypeCheckLoc) {
   auto &Ctx = AFD->getASTContext();
+  DiagnosticSuppression suppression(Ctx.Diags);
 
-  // Set up a diagnostics engine that swallows diagnostics.
-  DiagnosticEngine Diags(Ctx.SourceMgr);
-
-  TypeChecker TC(Ctx, Diags);
+  TypeChecker TC(Ctx);
   return !TC.typeCheckAbstractFunctionBodyUntil(AFD, EndTypeCheckLoc);
 }
 
 bool swift::typeCheckTopLevelCodeDecl(TopLevelCodeDecl *TLCD) {
   auto &Ctx = static_cast<Decl *>(TLCD)->getASTContext();
-
-  // Set up a diagnostics engine that swallows diagnostics.
-  DiagnosticEngine Diags(Ctx.SourceMgr);
-
-  TypeChecker TC(Ctx, Diags);
+  DiagnosticSuppression suppression(Ctx.Diags);
+  TypeChecker TC(Ctx);
   TC.typeCheckTopLevelCodeDecl(TLCD);
   return true;
 }
 
-static void deleteTypeCheckerAndDiags(LazyResolver *resolver) {
-  DiagnosticEngine &diags = static_cast<TypeChecker*>(resolver)->Diags;
+static void deleteTypeChecker(LazyResolver *resolver) {
   delete resolver;
-  delete &diags;
 }
 
 OwnedResolver swift::createLazyResolver(ASTContext &Ctx) {
-  auto diags = new DiagnosticEngine(Ctx.SourceMgr);
-  return OwnedResolver(new TypeChecker(Ctx, *diags),
-                       &deleteTypeCheckerAndDiags);
+  return OwnedResolver(new TypeChecker(Ctx), &deleteTypeChecker);
 }
 
 // checkForForbiddenPrefix is for testing purposes.

lib/Sema/TypeChecker.h

@@ -726,8 +726,7 @@ class TypeChecker final : public LazyResolver {
   Expr* constructCallToSuperInit(ConstructorDecl *ctor, ClassDecl *ClDecl);
 
 public:
-  TypeChecker(ASTContext &Ctx) : TypeChecker(Ctx, Ctx.Diags) { }
-  TypeChecker(ASTContext &Ctx, DiagnosticEngine &Diags);
+  TypeChecker(ASTContext &Ctx);
   TypeChecker(const TypeChecker&) = delete;
   TypeChecker& operator=(const TypeChecker&) = delete;
   ~TypeChecker();

test/IRGen/playground.swift

@@ -9,6 +9,12 @@ import Swift
 
 @objc class C { }
 
+private func __builtin_log_scope_entry(_ startLine: Int, _ startColumn: Int,
+  _ endLine: Int, _ endColumn: Int) { }
+private func __builtin_log_scope_exit(_ startLine: Int, _ startColumn: Int,
+  _ endLine: Int, _ endColumn: Int) { }
+private func __builtin_send_data<T>(_ object: T) { }
+
 public func anchor() {}
 
 anchor()