[clang] Frontend insight remarks PoC

[jkorous]

Summary

Proof of concept of "compilation logging" that would provide users with insight into how Sema interprets C++ standard.

clang/include/clang/Basic/DiagnosticGroups.td

 def NoDeref : DiagGroup<"noderef">;
 
 // A group for cross translation unit static analysis related warnings.
 def CrossTU : DiagGroup<"ctu">;
 
 def CTADMaybeUnsupported : DiagGroup<"ctad-maybe-unsupported">;
 
 def FortifySource : DiagGroup<"fortify-source">;
+// Frontend insight remarks.
+
+def SpecialMemberGeneration : DiagGroup<"special-member-generated">;
+def NameResolution : DiagGroup<"name-resolution">;
+def DefaultValue : DiagGroup<"default-value">;
+def ImplicitConversion : DiagGroup<"implicit-conversion">;
+
+def InsightRemarks : DiagGroup<"insight", [
+  SpecialMemberGeneration,
+  NameResolution,
+  DefaultValue,
+  ImplicitConversion
+]>;

clang/include/clang/Basic/DiagnosticIDs.h

public:
   /// Get the set of all diagnostic IDs.
   static void getAllDiagnostics(diag::Flavor Flavor,
                                 std::vector<diag::kind> &Diags);
 
   /// Get the diagnostic option with the closest edit distance to the
   /// given group name.
   static StringRef getNearestOption(diag::Flavor Flavor, StringRef Group);
 
-private:
   /// Classify the specified diagnostic ID into a Level, consumable by
   /// the DiagnosticClient.
   ///
   /// The classification is based on the way the client configured the
   /// DiagnosticsEngine object.
   ///
   /// \param Loc The source location for which we are interested in finding out
   /// the diagnostic state. Can be null in order to query the latest state.
   DiagnosticIDs::Level
   getDiagnosticLevel(unsigned DiagID, SourceLocation Loc,
                      const DiagnosticsEngine &Diag) const LLVM_READONLY;
 
+private:
   diag::Severity
   getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
                         const DiagnosticsEngine &Diag) const LLVM_READONLY;
 
   /// Used to report a diagnostic that is finally fully formed.
   ///
   /// \returns \c true if the diagnostic was emitted, \c false if it was
   /// suppressed.

clang/include/clang/Basic/DiagnosticOptions.h

 //===- DiagnosticOptions.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H
 #define LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H
 
 #include "clang/Basic/LLVM.h"
+#include "clang/Frontend/CommandLineSourceLoc.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include <string>
 #include <type_traits>
 #include <vector>
 
 namespace clang {
 
 /// Specifies which overload candidates to display when overload
public:
   /// The list of -W... options used to alter the diagnostic mappings, with the
   /// prefixes removed.
   std::vector<std::string> Warnings;
 
   /// The list of -R... options used to alter the diagnostic mappings, with the
   /// prefixes removed.
   std::vector<std::string> Remarks;
 
+  /// Code range for which insight remarks shall be produced.
+  llvm::Optional<ParsedSourceRange> InsightRemarksRange;
+
   /// The prefixes for comment directives sought by -verify ("expected" by
   /// default).
   std::vector<std::string> VerifyPrefixes;
 
 public:
   // Define accessors/mutators for diagnostic options of enumeration type.
 #define DIAGOPT(Name, Bits, Default)
 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \

clang/include/clang/Basic/DiagnosticOptions.def

 SEMANTIC_DIAGOPT(IgnoreWarnings, 1, 0)   /// -w
 DIAGOPT(NoRewriteMacros, 1, 0)  /// -Wno-rewrite-macros
 DIAGOPT(Pedantic, 1, 0)         /// -pedantic
 DIAGOPT(PedanticErrors, 1, 0)   /// -pedantic-errors
 DIAGOPT(ShowColumn, 1, 1)       /// Show column number on diagnostics.
 DIAGOPT(ShowLocation, 1, 1)     /// Show source location information.
 DIAGOPT(AbsolutePath, 1, 0)     /// Use absolute paths.
 DIAGOPT(ShowCarets, 1, 1)       /// Show carets in diagnostics.
+DIAGOPT(HideContextStack, 1, 0)  /// Suppress context stack printing.
 DIAGOPT(ShowFixits, 1, 1)       /// Show fixit information.
 DIAGOPT(ShowSourceRanges, 1, 0) /// Show source ranges in numeric form.
 DIAGOPT(ShowParseableFixits, 1, 0) /// Show machine parseable fix-its.
 DIAGOPT(ShowPresumedLoc, 1, 0)  /// Show presumed location for diagnostics.
 DIAGOPT(ShowOptionNames, 1, 0)  /// Show the option name for mappable
                                 /// diagnostics.
 DIAGOPT(ShowNoteIncludeStack, 1, 0) /// Show include stacks for notes.
 VALUE_DIAGOPT(ShowCategories, 2, 0) /// Show categories: 0 -> none, 1 -> Number,

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_builtin_launder_invalid_arg : Error<
   "%select{non-pointer|function pointer|void pointer}0 argument to "
   "'__builtin_launder' is not allowed">;
 
 def err_bit_cast_non_trivially_copyable : Error<
   "__builtin_bit_cast %select{source|destination}0 type must be trivially copyable">;
 def err_bit_cast_type_size_mismatch : Error<
   "__builtin_bit_cast source size does not equal destination size (%0 vs %1)">;
+// InsightRemarks
+def remark_implicit_default_ctor_generated : Remark<
+  "implicit default constructor was generated for class %0">,
+  InGroup<SpecialMemberGeneration>;
+def remark_implicit_copy_ctor_generated : Remark<
+  "implicit copy constructor was generated for class %0">,
+  InGroup<SpecialMemberGeneration>;
+def remark_implicit_move_ctor_generated : Remark<
+  "implicit move constructor was generated for class %0">,
+  InGroup<SpecialMemberGeneration>;
+def remark_implicit_copy_assignment_generated : Remark<
+  "implicit copy assignment operator was generated for class %0">,
+  InGroup<SpecialMemberGeneration>;
+def remark_implicit_move_assignment_generated : Remark<
+  "implicit move assignment operator was generated for class %0">,
+  InGroup<SpecialMemberGeneration>;
+def remark_implicit_dtor_generated : Remark<
+  "implicit destructor was generated for class %0">,
+  InGroup<SpecialMemberGeneration>;
+
+def remark_function_overload_considered_in_resolution : Remark<
+  "%0 %1 of signature %2 considered in resolution of %3">,
+  InGroup<NameResolution>;
+
+def remark_default_template_argument : Remark<
+  "default value %0 used for %1 argument %2 in instantiation of template %3">,
+  InGroup<DefaultValue>;
+
+def remark_using_implicit_conversion : Remark<
+  "using implicit conversion from %0 to %1">,
+  InGroup<ImplicitConversion>;
 } // end of sema component.

clang/include/clang/Driver/CC1Options.td

def verify : Flag<["-"], "verify">,
   HelpText<"Equivalent to -verify=expected">;
 def verify_ignore_unexpected : Flag<["-"], "verify-ignore-unexpected">,
   HelpText<"Ignore unexpected diagnostic messages">;
 def verify_ignore_unexpected_EQ : CommaJoined<["-"], "verify-ignore-unexpected=">,
   HelpText<"Ignore unexpected diagnostic messages">;
 def Wno_rewrite_macros : Flag<["-"], "Wno-rewrite-macros">,
   HelpText<"Silence ObjC rewriting warnings">;
 
+def insight_remarks_range : Flag<["-"], "insight-remarks-range">,
+  MetaVarName<"<file>:<line_begin>:<column_begin>-<line_end>:<column_end>">,
+  HelpText<"Print insight remarks only for given range.">;
+def insight_remarks_range_EQ : Joined<["-"], "insight-remarks-range=">,
+  Alias<insight_remarks_range>;
+
+
 //===----------------------------------------------------------------------===//
 // Frontend Options
 //===----------------------------------------------------------------------===//
 
 // This isn't normally used, it is just here so we can parse a
 // CompilerInvocation out of a driver-derived argument vector.
 def cc1 : Flag<["-"], "cc1">;
 def cc1as : Flag<["-"], "cc1as">;

clang/lib/Frontend/CompilerInvocation.cpp

if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
     if (Diags)
       Diags->Report(diag::warn_ignoring_ftabstop_value)
       << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
   }
   Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
   addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
   addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
 
+  if (const Arg *A = Args.getLastArg(OPT_insight_remarks_range)) {
+    Opts.InsightRemarksRange = ParsedSourceRange::fromString(A->getValue());
+    if (Opts.InsightRemarksRange &&
+        Opts.InsightRemarksRange.getValue().FileName.empty())
+      Diags->Report(diag::err_drv_invalid_value)
+          << A->getAsString(Args) << A->getValue();
+  }
+
   return Success;
 }
 
 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
   Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
 }
 
 /// Parse the argument to the -ftest-module-file-extension

clang/lib/Sema/CMakeLists.txt

clang_tablegen(OpenCLBuiltins.inc -gen-clang-opencl-builtins
   )
 
 add_clang_library(clangSema
   AnalysisBasedWarnings.cpp
   CodeCompleteConsumer.cpp
   DeclSpec.cpp
   DelayedDiagnostic.cpp
   IdentifierResolver.cpp
+  InsightRemarks.cpp
   JumpDiagnostics.cpp
   MultiplexExternalSemaSource.cpp
   ParsedAttr.cpp
   Scope.cpp
   ScopeInfo.cpp
   Sema.cpp
   SemaAccess.cpp
   SemaAttr.cpp

clang/lib/Sema/InsightRemarks.h

+//===--- InsightRemarks.h - Utilities for insight remarks -------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file contains utilities for insight remarks.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_SEMA_INSIGHTREMARKS_H
+#define LLVM_CLANG_LIB_SEMA_INSIGHTREMARKS_H
+
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/CommandLineSourceLoc.h"
+#include "clang/Sema/Sema.h"
+#include "llvm/ADT/Optional.h"
+
+namespace clang {
+
+bool isInsideInsightRange(
+    const SourceManager &SM, const SourceLocation &Loc,
+    const llvm::Optional<ParsedSourceRange> &InsightRemarksRange);
+
+/// Prints insight remark if Loc is within InsightRange
+void printInsightRemark(
+    Sema &S, SourceLocation Loc, unsigned DiagID,
+    std::function<void(DiagnosticBuilder &)> RemarkProducer);
+
+} // namespace clang
+
+#endif

clang/lib/Sema/InsightRemarks.cpp

+//===--- InsightRemarks.cpp - Utilities for insight remarks -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file contains utilities for insight remarks.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InsightRemarks.h"
+#include "llvm/ADT/StringRef.h"
+#include <utility>
+
+namespace clang {
+
+inline bool isInsideInsightRange(
+    const SourceManager &SM, const SourceLocation &Loc,
+    const llvm::Optional<ParsedSourceRange> &InsightRemarksRange) {
+  if (!InsightRemarksRange) // Range is not set ==> output insight remarks
+                            // everywhere
+    return true;
+
+  const auto &Range = InsightRemarksRange.getValue();
+  assert(!Range.FileName.empty() && "FileName is not set");
+
+  const std::pair<FileID, unsigned> DecLoc = SM.getDecomposedLoc(Loc);
+  StringRef Filename = SM.getFilename(Loc);
+  const std::size_t LineNum = SM.getLineNumber(DecLoc.first, DecLoc.second);
+  const std::size_t ColumnNum = SM.getColumnNumber(DecLoc.first, DecLoc.second);
+
+  return Filename == Range.FileName
+         // Loc is NOT OUTSIDE of the Range
+         &&
+         !(LineNum < Range.Begin.first || LineNum > Range.End.first ||
+           (LineNum == Range.Begin.first && ColumnNum < Range.Begin.second) ||
+           (LineNum == Range.End.first && ColumnNum > Range.End.second));
+};
+
+/// Prints insight remark if Loc is within InsightRange
+void printInsightRemark(
+    Sema &S, SourceLocation Loc, unsigned DiagID,
+    std::function<void(DiagnosticBuilder &)> RemarkProducer) {
+  if (S.Diags.getDiagnosticIDs()->getDiagnosticLevel(
+          DiagID, SourceLocation(), S.Diags) != DiagnosticIDs::Level::Ignored &&
+      isInsideInsightRange(
+          S.getSourceManager(), Loc,
+          S.Diags.getDiagnosticOptions().InsightRemarksRange)) {
+    // Turn off caret and context printing for the remark and restore
+    // afterwards.
+    const bool ShowCarets = S.Diags.getDiagnosticOptions().ShowCarets;
+    const bool HideContextStack =
+        S.Diags.getDiagnosticOptions().HideContextStack;
+
+    S.Diags.getDiagnosticOptions().ShowCarets = false;
+    S.Diags.getDiagnosticOptions().HideContextStack = true;
+    {
+      auto DiagBuilder = S.Diag(Loc, DiagID);
+      RemarkProducer(DiagBuilder);
+      // Destructor of DiagBuilder triggers diagnostics emitting.
+      // Need to finish that before diag options are restored.
+    }
+    S.Diags.getDiagnosticOptions().ShowCarets = ShowCarets;
+    S.Diags.getDiagnosticOptions().HideContextStack = HideContextStack;
+  }
+}
+
+} // namespace clang
 No newline at end of file

clang/lib/Sema/Sema.cpp

 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the actions class which performs semantic analysis and
 // builds an AST out of a parse stream.
 //
 //===----------------------------------------------------------------------===//
 
+#include "InsightRemarks.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
   // Emit the diagnostic.
   if (!Diags.EmitCurrentDiagnostic())
     return;
 
   // If this is not a note, and we're in a template instantiation
   // that is different from the last template instantiation where
   // we emitted an error, print a template instantiation
   // backtrace.
-  if (!DiagnosticIDs::isBuiltinNote(DiagID))
+  if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
+      !Diags.getDiagnosticOptions().HideContextStack)
     PrintContextStack();
 }
 
 Sema::SemaDiagnosticBuilder
 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
   SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
   PD.Emit(Builder);
 

clang/lib/Sema/SemaDeclCXX.cpp

 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ declarations.
 //
 //===----------------------------------------------------------------------===//
 
+#include "InsightRemarks.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/ComparisonCategories.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
 
   if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
     SetDeclDeleted(DefaultCon, ClassLoc);
 
   if (S)
     PushOnScopeChains(DefaultCon, S, false);
   ClassDecl->addDecl(DefaultCon);
 
+  printInsightRemark(*this, DefaultCon->getLocation(),
+                     diag::remark_implicit_default_ctor_generated,
+                     [&](DiagnosticBuilder &db) { db << ClassDecl; });
   return DefaultCon;
 }
 
 void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
                                             CXXConstructorDecl *Constructor) {
   assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
           !Constructor->doesThisDeclarationHaveABody() &&
           !Constructor->isDeleted()) &&
if (ClassDecl->isCompleteDefinition() &&
       ShouldDeleteSpecialMember(Destructor, CXXDestructor))
     SetDeclDeleted(Destructor, ClassLoc);
 
   // Introduce this destructor into its scope.
   if (S)
     PushOnScopeChains(Destructor, S, false);
   ClassDecl->addDecl(Destructor);
 
+  printInsightRemark(*this, Destructor->getLocation(),
+                     diag::remark_implicit_dtor_generated,
+                     [&](DiagnosticBuilder &db) { db << ClassDecl; });
+
   return Destructor;
 }
 
 void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
                                     CXXDestructorDecl *Destructor) {
   assert((Destructor->isDefaulted() &&
           !Destructor->doesThisDeclarationHaveABody() &&
           !Destructor->isDeleted()) &&
CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
 
   if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
     SetDeclDeleted(CopyAssignment, ClassLoc);
 
   if (S)
     PushOnScopeChains(CopyAssignment, S, false);
   ClassDecl->addDecl(CopyAssignment);
 
+  printInsightRemark(*this, CopyAssignment->getLocation(),
+                     diag::remark_implicit_copy_assignment_generated,
+                     [&](DiagnosticBuilder &db) { db << ClassDecl; });
+
   return CopyAssignment;
 }
 
 /// Diagnose an implicit copy operation for a class which is odr-used, but
 /// which is deprecated because the class has a user-declared copy constructor,
 /// copy assignment operator, or destructor.
 static void diagnoseDeprecatedCopyOperation(Sema &S, CXXMethodDecl *CopyOp) {
   assert(CopyOp->isImplicit());
if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
     ClassDecl->setImplicitMoveAssignmentIsDeleted();
     SetDeclDeleted(MoveAssignment, ClassLoc);
   }
 
   if (S)
     PushOnScopeChains(MoveAssignment, S, false);
   ClassDecl->addDecl(MoveAssignment);
 
+  printInsightRemark(*this, MoveAssignment->getLocation(),
+                     diag::remark_implicit_move_assignment_generated,
+                     [&](DiagnosticBuilder &db) { db << ClassDecl; });
+
   return MoveAssignment;
 }
 
 /// Check if we're implicitly defining a move assignment operator for a class
 /// with virtual bases. Such a move assignment might move-assign the virtual
 /// base multiple times.
 static void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class,
                                                SourceLocation CurrentLocation) {
if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor)) {
     ClassDecl->setImplicitCopyConstructorIsDeleted();
     SetDeclDeleted(CopyConstructor, ClassLoc);
   }
 
   if (S)
     PushOnScopeChains(CopyConstructor, S, false);
   ClassDecl->addDecl(CopyConstructor);
 
+  printInsightRemark(*this, CopyConstructor->getLocation(),
+                     diag::remark_implicit_copy_ctor_generated,
+                     [&](DiagnosticBuilder &db) { db << ClassDecl; });
+
   return CopyConstructor;
 }
 
 void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
                                          CXXConstructorDecl *CopyConstructor) {
   assert((CopyConstructor->isDefaulted() &&
           CopyConstructor->isCopyConstructor() &&
           !CopyConstructor->doesThisDeclarationHaveABody() &&
if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
     ClassDecl->setImplicitMoveConstructorIsDeleted();
     SetDeclDeleted(MoveConstructor, ClassLoc);
   }
 
   if (S)
     PushOnScopeChains(MoveConstructor, S, false);
   ClassDecl->addDecl(MoveConstructor);
 
+  printInsightRemark(*this, MoveConstructor->getLocation(),
+                     diag::remark_implicit_move_ctor_generated,
+                     [&](DiagnosticBuilder &db) { db << ClassDecl; });
+
   return MoveConstructor;
 }
 
 void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
                                          CXXConstructorDecl *MoveConstructor) {
   assert((MoveConstructor->isDefaulted() &&
           MoveConstructor->isMoveConstructor() &&
           !MoveConstructor->doesThisDeclarationHaveABody() &&

clang/lib/Sema/SemaExprCXX.cpp

 //===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Implements semantic analysis for C++ expressions.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "clang/Sema/SemaInternal.h"
+#include "InsightRemarks.h"
 #include "TreeTransform.h"
 #include "TypeLocBuilder.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaLambda.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ErrorHandling.h"
 using namespace clang;
 using namespace sema;
 
if (SCS.CopyConstructor) {
     // FIXME: When can ToType be a reference type?
     assert(!ToType->isReferenceType());
     if (SCS.Second == ICK_Derived_To_Base) {
       SmallVector<Expr*, 8> ConstructorArgs;
       if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
                                   From, /*FIXME:ConstructLoc*/SourceLocation(),
                                   ConstructorArgs))
         return ExprError();
+
+      printInsightRemark(
+          *this, From->getExprLoc(), diag::remark_default_template_argument,
+          [&](DiagnosticBuilder &db) { db << FromType << ToType; });
+
       return BuildCXXConstructExpr(
           /*FIXME:ConstructLoc*/ SourceLocation(), ToType,
           SCS.FoundCopyConstructor, SCS.CopyConstructor,
           ConstructorArgs, /*HadMultipleCandidates*/ false,
           /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
           CXXConstructExpr::CK_Complete, SourceRange());
     }
     return BuildCXXConstructExpr(

clang/lib/Sema/SemaInit.cpp

 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements semantic analysis for initializers.
 //
 //===----------------------------------------------------------------------===//
 
+#include "InsightRemarks.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Designator.h"
ExprResult InitializationSequence::Perform(Sema &S,
   // FIXME: Ugly hack around the fact that Entity.getType() is not
   // the same as Entity.getDecl()->getType() in cases involving type merging,
   //  and we want latter when it makes sense.
   if (ResultType)
     *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
                                      Entity.getType();
 
   ExprResult CurInit((Expr *)nullptr);
+  ExprResult LastInit;
   SmallVector<Expr*, 4> ArrayLoopCommonExprs;
 
   // For initialization steps that start with a single initializer,
   // grab the only argument out the Args and place it into the "current"
   // initializer.
   switch (Steps.front().Kind) {
   case SK_ResolveAddressOfOverloadedFunction:
   case SK_CastDerivedToBaseRValue:
ExprResult InitializationSequence::Perform(Sema &S,
 
   // Walk through the computed steps for the initialization sequence,
   // performing the specified conversions along the way.
   bool ConstructorInitRequiresZeroInit = false;
   for (step_iterator Step = step_begin(), StepEnd = step_end();
        Step != StepEnd; ++Step) {
     if (CurInit.isInvalid())
       return ExprError();
+    LastInit = CurInit;
 
     QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
 
     switch (Step->Kind) {
     case SK_ResolveAddressOfOverloadedFunction:
       // Overload resolution determined which function invoke; update the
       // initializer to reflect that choice.
       S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
case SK_OCLZeroOpaqueType: {
              "Wrong type for initialization of OpenCL opaque type.");
 
       CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
                                     CK_ZeroToOCLOpaqueType,
                                     CurInit.get()->getValueKind());
       break;
     }
     }
+    if (LastInit.isUsable() && LastInit.get()->getType() != Step->Type) {
+      printInsightRemark(S, Kind.getLocation(),
+                         diag::remark_using_implicit_conversion,
+                         [&](DiagnosticBuilder &db) {
+                           db << LastInit.get()->getType() << Step->Type;
+                         });
+    }
   }
 
   // Check whether the initializer has a shorter lifetime than the initialized
   // entity, and if not, either lifetime-extend or warn as appropriate.
   if (auto *Init = CurInit.get())
     S.checkInitializerLifetime(Entity, Init);
 
   // Diagnose non-fatal problems with the completed initialization.

clang/lib/Sema/SemaOverload.cpp

 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides Sema routines for C++ overloading.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Sema/Overload.h"
+#include "InsightRemarks.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/TypeOrdering.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
+#include "clang/Sema/Overload.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
if (CandidateSet->empty() ||
       *Result = CE;
       return true;
     }
   }
 
   if (CandidateSet->empty())
     return false;
 
+  for (const auto &candidate : *CandidateSet) {
+    if (candidate.Function) {
+
+      const char *func_kind = nullptr;
+      switch (candidate.Function->getTemplatedKind()) {
+      case FunctionDecl::TK_FunctionTemplate:
+        func_kind = "function template";
+        break;
+      case FunctionDecl::TK_FunctionTemplateSpecialization:
+      case FunctionDecl::TK_MemberSpecialization:
+      case FunctionDecl::TK_DependentFunctionTemplateSpecialization:
+        func_kind = "function template specialization";
+        break;
+      case FunctionDecl::TK_NonTemplate:
+        func_kind = "function";
+      }
+
+      printInsightRemark(
+          *this, Fn->getExprLoc(),
+          diag::remark_function_overload_considered_in_resolution,
+          [&](DiagnosticBuilder &db) {
+            db << func_kind << candidate.Function
+               << candidate.Function->getType() << Fn;
+          });
+    }
+  }
+
   UnbridgedCasts.restore();
   return false;
 }
 
 /// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
 /// the completed call expression. If overload resolution fails, emits
 /// diagnostics and returns ExprError()
 static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,

clang/lib/Sema/SemaTemplate.cpp

 //===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ templates.
 //===----------------------------------------------------------------------===//
 
+#include "InsightRemarks.h"
 #include "TreeTransform.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
       TemplateArgLists.addOuterTemplateArguments(None);
 
     Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
     ArgType =
         SemaRef.SubstType(ArgType, TemplateArgLists,
                           Param->getDefaultArgumentLoc(), Param->getDeclName());
   }
 
+  printInsightRemark(SemaRef, TemplateLoc,
+                     diag::remark_default_template_argument,
+                     [&](DiagnosticBuilder &db) {
+                       db << Param->getDefaultArgument() << "non-template type"
+                          << Param << Template;
+                     });
+
   return ArgType;
 }
 
 /// Substitute template arguments into the default template argument for
 /// the given non-type template parameter.
 ///
 /// \param SemaRef the semantic analysis object for which we are performing
 /// the substitution.
SubstDefaultTemplateArgument(Sema &SemaRef,
   TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
 
   // Only substitute for the innermost template argument list.
   MultiLevelTemplateArgumentList TemplateArgLists;
   TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
   for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
     TemplateArgLists.addOuterTemplateArguments(None);
 
+  printInsightRemark(
+      SemaRef, TemplateLoc, diag::remark_default_template_argument,
+      [&](DiagnosticBuilder &db) {
+        db << Param->getDefaultArgument() << "non-type" << Param << Template;
+      });
+
   EnterExpressionEvaluationContext ConstantEvaluated(
       SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
   return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
 }
 
 /// Substitute template arguments into the default template argument for
 /// the given template template parameter.
 ///
SubstDefaultTemplateArgument(Sema &SemaRef,
   QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
   if (QualifierLoc) {
     QualifierLoc =
         SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
     if (!QualifierLoc)
       return TemplateName();
   }
 
+  printInsightRemark(SemaRef, TemplateLoc,
+                     diag::remark_default_template_argument,
+                     [&](DiagnosticBuilder &db) {
+                       db << Param->getDefaultArgument().getArgument()
+                          << "template type" << Param << Template;
+                     });
+
   return SemaRef.SubstTemplateName(
              QualifierLoc,
              Param->getDefaultArgument().getArgument().getAsTemplate(),
              Param->getDefaultArgument().getTemplateNameLoc(),
              TemplateArgLists);
 }
 
 /// If the given template parameter has a default template

clang/test/Frontend/insight-remarks-default-values.cpp

+// RUN: %clang -cc1 -std=c++17 -Rdefault-value -fsyntax-only %s 2>&1 | FileCheck %s
+template<class T = bool> class foo {
+    T memfoo;
+};
+
+template<int N = 42> class bar {
+    int n = N;
+};
+
+template<template<typename> typename C = foo> class baz {
+};
+
+int main() {
+    foo<> x;
+// CHECK: remark: default value 'bool' used for non-template type argument 'T' in instantiation of template 'foo'
+    bar<> y;
+// CHECK: remark: default value 42 used for non-type argument 'N' in instantiation of template 'bar'
+    baz<> z;
+// CHECK: remark: default value 'foo' used for template type argument 'C' in instantiation of template 'baz'
+}
 No newline at end of file

clang/test/Frontend/insight-remarks-implicit-conversion.cpp

+// RUN: %clang -cc1 -Rimplicit-conversion -fsyntax-only %s 2>&1 | FileCheck %s
+
+void foof(bool) {}
+
+int main() {
+  {
+    struct foo {
+      operator int() { return 42; }
+    };
+
+    foo b;
+    int a = b;
+// CHECK: remark: using implicit conversion from 'foo' to 'int'
+  }
+  {
+    int a = 3;
+    unsigned b = 4;
+// CHECK: remark: using implicit conversion from 'int' to 'unsigned int'
+    unsigned long long c = a + b;
+// CHECK: remark: using implicit conversion from 'unsigned int' to 'unsigned long long'
+    foof(a);
+// CHECK: remark: using implicit conversion from 'int' to 'bool'
+  }
+  {
+    struct bar {};
+    struct foo {
+      bar b;
+      operator bar() { return b; }
+// CHECK: remark: using implicit conversion from 'bar' to 'const bar'
+    };
+    foo f;
+    const bar& b = f;
+// CHECK: remark: using implicit conversion from 'foo' to 'bar'
+// CHECK: remark: using implicit conversion from 'bar' to 'const bar'
+  }
+  {
+    short a;
+    const unsigned short& b = a;
+// CHECK: remark: using implicit conversion from 'short' to 'const unsigned short'
+  }
+  {
+    struct foo {
+      static void bar(const int&){}
+    };
+    int a = 3;
+    foo::bar(a);
+// CHECK: remark: using implicit conversion from 'int' to 'const int'
+  }
+  {
+    struct foo {};
+    struct bar : foo {};
+    struct local { static void f(const foo &) {} };
+    bar b;
+    local::f(b);
+// CHECK: remark: using implicit conversion from 'bar' to 'const bar'
+// CHECK: remark: using implicit conversion from 'const bar' to 'const foo'
+  }
+  {
+    char a[5];
+
+    const char* b = a;
+// CHECK: remark: using implicit conversion from 'char [5]' to 'const char *'
+
+    struct local { static void foo(const char*) {} };
+    local::foo(a);
+// CHECK: remark: using implicit conversion from 'char [5]' to 'const char *'
+  }
+  {
+    long a = 5;
+    if(a)
+      a = 7;
+// CHECK: remark: using implicit conversion from 'int' to 'long'
+  }
+}
 No newline at end of file

clang/test/Frontend/insight-remarks-overloaded-function.cpp

+// RUN: %clang -cc1 -Rname-resolution -fsyntax-only %s 2>&1 | FileCheck %s
+
+namespace {
+  void foo() {}
+}
+void foo(int) {}
+void foo(int*) {}
+
+template<class T> void foo(T) { }
+
+int main() {
+  foo();
+// CHECK: remark: function template 'foo' of signature 'void (T)' considered in resolution of foo
+// CHECK: remark: function 'foo' of signature 'void (int *)' considered in resolution of foo
+// CHECK: remark: function 'foo' of signature 'void (int)' considered in resolution of foo
+// CHECK: remark: function 'foo' of signature 'void ()' considered in resolution of foo
+  foo(5);
+// CHECK: remark: function template specialization 'foo<int>' of signature 'void (int)' considered in resolution of foo
+// CHECK: remark: function 'foo' of signature 'void (int *)' considered in resolution of foo
+// CHECK: remark: function 'foo' of signature 'void (int)' considered in resolution of foo
+// CHECK: remark: function 'foo' of signature 'void ()' considered in resolution of foo
+}

clang/test/Frontend/insight-remarks-range.cpp

+// RUN: %clang -cc1 -Rinsight -insight-remarks-range=%s:4:16-4:32 -fsyntax-only %s 2>&1 | FileCheck %s
+
+class hay1 {};
+class hay2 {}; class needle {}; class hay3 {};
+// CHECK: needle
+class hay4 {};
+
+int main() {
+  hay1 h1;
+  hay2 h2;
+  hay3 h3;
+  hay4 h4;
+  needle n;
+}
 No newline at end of file

clang/test/Frontend/insight-remarks-special-members-generated.cpp

+// RUN: %clang -cc1 -Rspecial-member-generated -fsyntax-only %s 2>&1 | FileCheck %s
+
+class foo {
+// CHECK: remark: implicit default constructor was generated for class 'foo'
+// CHECK: remark: implicit copy constructor was generated for class 'foo'
+// CHECK: remark: implicit move constructor was generated for class 'foo'
+  int a;
+};
+
+int main() {
+  foo x;
+}
 No newline at end of file