[modules] Replace `-Wauto-import` with `-Rmodule-include-translation`.

[vsapsai]

Summary

Diagnostic for -Wauto-import shouldn't be a warning because it doesn't
represent a potential problem in code that should be fixed. And the
emitted fix-it is likely to trigger -Watimport-in-framework-header
which makes it challenging to have a warning-free codebase. But it is
still useful to see how include directives are translated into modular
imports and which module a header belongs to, that's why keep it as a remark.

Keep -Wauto-import for now to allow a gradual migration for codebases
using -Wno-auto-import, e.g., -Weverything -Wno-auto-import.

rdar://79594287

[vsapsai]

Not sure about the name of the flag -Rmodule-include-translation, seems to be verbose. So suggestions about the flag name are welcome. On the other hand, "auto-import" is expected to mean something else, for example, adding missing imports. And changing the name looks like an improvement.

[iains]

makes sense to me...

I guess the name looks long at first, but it's specific (I find that easy-to-remember flag names are more important than short-to-type ones, but maybe that's just me) - I wonder if @MaskRay has any comments on the flag name,

For the record:
GCC uses : -flang-info-include-translate (-flang for flag-language, rather than 'flang', of course).
(which is a note, i.e. similar idea to the remark)

BTW.. (not for this patch, of course)
GCC also has
info-include-translate-not
Note #include directives not translated to import declarations, and not known to be textual.

[vsapsai]

Looks like GCC has some naming pattern there, thanks for sharing, Iain. So I want to share the pattern I'm aiming for. I'd like the flag to start with -Rmodule-... to be consistent with -Rmodule-build, -Rmodule-import, -Rmodule-lock.

[MaskRay]

In D130138#3664913, @iains wrote:

makes sense to me...

I guess the name looks long at first, but it's specific (I find that easy-to-remember flag names are more important than short-to-type ones, but maybe that's just me) - I wonder if @MaskRay has any comments on the flag name,

For the record:
GCC uses : -flang-info-include-translate (-flang for flag-language, rather than 'flang', of course).
(which is a note, i.e. similar idea to the remark)

BTW.. (not for this patch, of course)
GCC also has
info-include-translate-not
Note #include directives not translated to import declarations, and not known to be textual.

Using remarks is suitable and the new name -Rmodule-include-translation looks good to me.

Thanks for mentioning similar options from GCC. The names feel a bit odd to me as I am thinking what "lang-info" means.

[iains]

In D130138#3667172, @MaskRay wrote:

In D130138#3664913, @iains wrote:

makes sense to me...

I guess the name looks long at first, but it's specific (I find that easy-to-remember flag names are more important than short-to-type ones, but maybe that's just me) - I wonder if @MaskRay has any comments on the flag name,

For the record:
GCC uses : -flang-info-include-translate (-flang for flag-language, rather than 'flang', of course).
(which is a note, i.e. similar idea to the remark)

BTW.. (not for this patch, of course)
GCC also has
info-include-translate-not
Note #include directives not translated to import declarations, and not known to be textual.

Using remarks is suitable and the new name -Rmodule-include-translation looks good to me.

Thanks for mentioning similar options from GCC. The names feel a bit odd to me as I am thinking what "lang-info" means.

GCC does not have the exact equivalent of 'remark' (so lang-info is something specific to the language being compiled).

This seems like something we should aim to get into llvm-15, so LGTM given the comments above.

[vsapsai]

Thanks for the review!

clang/include/clang/Basic/DiagnosticGroups.td

 def GNUAnonymousStruct : DiagGroup<"gnu-anonymous-struct">;
 def GNUAutoType : DiagGroup<"gnu-auto-type">;
 def ArrayBounds : DiagGroup<"array-bounds">;
 def ArrayBoundsPointerArithmetic : DiagGroup<"array-bounds-pointer-arithmetic">;
 def ArrayParameter : DiagGroup<"array-parameter">;
 def AutoDisableVptrSanitizer : DiagGroup<"auto-disable-vptr-sanitizer">;
 def Availability : DiagGroup<"availability">;
 def Section : DiagGroup<"section">;
-def AutoImport : DiagGroup<"auto-import">;
+def : DiagGroup<"auto-import">;
 def FrameworkHdrQuotedInclude : DiagGroup<"quoted-include-in-framework-header">;
 def FrameworkIncludePrivateFromPublic :
   DiagGroup<"framework-include-private-from-public">;
 def FrameworkHdrAtImport : DiagGroup<"atimport-in-framework-header">;
 def CXX14BinaryLiteral : DiagGroup<"c++14-binary-literal">;
 def CXXPre14CompatBinaryLiteral : DiagGroup<"c++98-c++11-compat-binary-literal">;
 def GNUBinaryLiteral : DiagGroup<"gnu-binary-literal">;
 def BinaryLiteral : DiagGroup<"binary-literal", [CXX14BinaryLiteral,

 def MismatchedReturnTypes : DiagGroup<"mismatched-return-types">;
 def MismatchedTags : DiagGroup<"mismatched-tags">;
 def MissingFieldInitializers : DiagGroup<"missing-field-initializers">;
 def ModuleLock : DiagGroup<"module-lock">;
 def ModuleBuild : DiagGroup<"module-build">;
 def ModuleImport : DiagGroup<"module-import">;
 def ModuleConflict : DiagGroup<"module-conflict">;
 def ModuleFileExtension : DiagGroup<"module-file-extension">;
+def ModuleIncludeDirectiveTranslation : DiagGroup<"module-include-translation">;
 def RoundTripCC1Args : DiagGroup<"round-trip-cc1-args">;
 def NewlineEOF : DiagGroup<"newline-eof">;
 def Nullability : DiagGroup<"nullability">;
 def NullabilityDeclSpec : DiagGroup<"nullability-declspec">;
 def NullabilityInferredOnNestedType : DiagGroup<"nullability-inferred-on-nested-type">;
 def NullableToNonNullConversion : DiagGroup<"nullable-to-nonnull-conversion">;
 def NullabilityCompletenessOnArrays : DiagGroup<"nullability-completeness-on-arrays">;
 def NullabilityCompleteness : DiagGroup<"nullability-completeness",

clang/include/clang/Basic/DiagnosticLexKinds.td

 def warn_quoted_include_in_framework_header : Warning<
   "double-quoted include \"%0\" in framework header, "
   "expected angle-bracketed instead"
   >, InGroup<FrameworkHdrQuotedInclude>, DefaultIgnore;
 def warn_framework_include_private_from_public : Warning<
   "public framework header includes private framework header '%0'"
   >, InGroup<FrameworkIncludePrivateFromPublic>;
 
-def warn_auto_module_import : Warning<
+def remark_pp_include_directive_modular_translation : Remark<
   "treating #%select{include|import|include_next|__include_macros}0 as an "
-  "import of module '%1'">, InGroup<AutoImport>, DefaultIgnore;
+  "import of module '%1'">, InGroup<ModuleIncludeDirectiveTranslation>;
 def note_implicit_top_level_module_import_here : Note<
   "submodule of top-level module '%0' implicitly imported here">;
 def warn_uncovered_module_header : Warning<
   "umbrella header for module '%0' does not include header '%1'">,
   InGroup<IncompleteUmbrella>;
 def warn_mmap_umbrella_dir_not_found : Warning<
   "umbrella directory '%0' not found">,
   InGroup<IncompleteUmbrella>;

clang/lib/Lex/PPDirectives.cpp

 }
 
 /// Produce a diagnostic informing the user that a #include or similar
 /// was implicitly treated as a module import.
 static void diagnoseAutoModuleImport(
     Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
     ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
     SourceLocation PathEnd) {
-  StringRef ImportKeyword;
-  if (PP.getLangOpts().ObjC)
-    ImportKeyword = "@import";
-  else if (PP.getLangOpts().ModulesTS || PP.getLangOpts().CPlusPlusModules)
-    ImportKeyword = "import";
-  else
-    return; // no import syntax available
-
   SmallString<128> PathString;
   for (size_t I = 0, N = Path.size(); I != N; ++I) {
     if (I)
       PathString += '.';
     PathString += Path[I].first->getName();
   }
-  int IncludeKind = 0;
 
+  int IncludeKind = 0;
   switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
   case tok::pp_include:
     IncludeKind = 0;
     break;
 
   case tok::pp_import:
     IncludeKind = 1;
     break;
 
   case tok::pp_include_next:
     IncludeKind = 2;
     break;
 
   case tok::pp___include_macros:
     IncludeKind = 3;
     break;
 
   default:
     llvm_unreachable("unknown include directive kind");
   }
 
-  CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd),
-                               /*IsTokenRange=*/false);
-  PP.Diag(HashLoc, diag::warn_auto_module_import)
-      << IncludeKind << PathString
-      << FixItHint::CreateReplacement(
-             ReplaceRange, (ImportKeyword + " " + PathString + ";").str());
+  PP.Diag(HashLoc, diag::remark_pp_include_directive_modular_translation)
+      << IncludeKind << PathString;
 }
 
 // Given a vector of path components and a string containing the real
 // path to the file, build a properly-cased replacement in the vector,
 // and return true if the replacement should be suggested.
 static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
                             StringRef RealPathName) {
   auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);

clang/test/Modules/auto-module-import.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -DERRORS
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -xobjective-c++ %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -DERRORS
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -xobjective-c++ %s -verify
 // 
 // Test both with and without the declarations that refer to unimported
 // entities. For error recovery, those cases implicitly trigger an import.
 
-#include <DependsOnModule/DependsOnModule.h> // expected-warning{{treating #include as an import of module 'DependsOnModule'}}
+#include <DependsOnModule/DependsOnModule.h> // expected-remark{{treating #include as an import of module 'DependsOnModule'}}
 
 #ifdef MODULE_H_MACRO
 #  error MODULE_H_MACRO should have been hidden
 #endif
 
 #ifdef DEPENDS_ON_MODULE
 #  error DEPENDS_ON_MODULE should have been hidden
 #endif
 
 #ifdef ERRORS
 Module *mod; // expected-error{{declaration of 'Module' must be imported from module 'Module' before it is required}}
 // expected-note@Inputs/Module.framework/Headers/Module.h:15 {{not visible}}
 #else
-#import <AlsoDependsOnModule/AlsoDependsOnModule.h> // expected-warning{{treating #import as an import of module 'AlsoDependsOnModule'}}
+#import <AlsoDependsOnModule/AlsoDependsOnModule.h> // expected-remark{{treating #import as an import of module 'AlsoDependsOnModule'}}
 #endif
 Module *mod2;
 
 int getDependsOther(void) { return depends_on_module_other; }
 
 void testSubframeworkOther(void) {
 #ifdef ERRORS
   double *sfo1 = sub_framework_other; // expected-error{{declaration of 'sub_framework_other' must be imported from module 'DependsOnModule.SubFramework.Other'}}
   // expected-note@Inputs/DependsOnModule.framework/Frameworks/SubFramework.framework/Headers/Other.h:15 {{not visible}}
 #endif
 }
 
 // Test umbrella-less submodule includes
-#include <NoUmbrella/A.h> // expected-warning{{treating #include as an import of module 'NoUmbrella.A'}}
+#include <NoUmbrella/A.h> // expected-remark{{treating #include as an import of module 'NoUmbrella.A'}}
 int getNoUmbrellaA(void) { return no_umbrella_A; } 
 
 // Test umbrella-less submodule includes
-#include <NoUmbrella/SubDir/C.h> // expected-warning{{treating #include as an import of module 'NoUmbrella.SubDir.C'}}
+#include <NoUmbrella/SubDir/C.h> // expected-remark{{treating #include as an import of module 'NoUmbrella.SubDir.C'}}
 int getNoUmbrellaC(void) { return no_umbrella_C; } 
 
 #ifndef ERRORS
 // Test header cross-subframework include pattern.
-#include <DependsOnModule/../Frameworks/SubFramework.framework/Headers/Other.h> // expected-warning{{treating #include as an import of module 'DependsOnModule.SubFramework.Other'}}
+#include <DependsOnModule/../Frameworks/SubFramework.framework/Headers/Other.h> // expected-remark{{treating #include as an import of module 'DependsOnModule.SubFramework.Other'}}
 #endif
 
 void testSubframeworkOtherAgain(void) {
   double *sfo1 = sub_framework_other;
 }
 
 void testModuleSubFramework(void) {
   char *msf = module_subframework;
 }
 
-#include <Module/../Frameworks/SubFramework.framework/Headers/SubFramework.h> // expected-warning{{treating #include as an import of module 'Module.SubFramework'}}
+#include <Module/../Frameworks/SubFramework.framework/Headers/SubFramework.h> // expected-remark{{treating #include as an import of module 'Module.SubFramework'}}
 
 void testModuleSubFrameworkAgain(void) {
   char *msf = module_subframework;
 }
 
 // Test inclusion of private headers.
-#include <DependsOnModule/DependsOnModulePrivate.h> // expected-warning{{treating #include as an import of module 'DependsOnModule.Private.DependsOnModule'}}
+#include <DependsOnModule/DependsOnModulePrivate.h> // expected-remark{{treating #include as an import of module 'DependsOnModule.Private.DependsOnModule'}}
 
 int getDependsOnModulePrivate(void) { return depends_on_module_private; }
 
 #include <Module/ModulePrivate.h> // includes the header
 
 int getModulePrivate(void) { return module_private; }
 
-#include <NoUmbrella/A_Private.h> // expected-warning{{treating #include as an import of module 'NoUmbrella.Private.A_Private'}}
+#include <NoUmbrella/A_Private.h> // expected-remark{{treating #include as an import of module 'NoUmbrella.Private.A_Private'}}
 int getNoUmbrellaAPrivate(void) { return no_umbrella_A_private; }
 
 int getNoUmbrellaBPrivateFail(void) { return no_umbrella_B_private; } // expected-error{{declaration of 'no_umbrella_B_private' must be imported from module 'NoUmbrella.Private.B_Private'}}
 // expected-note@Inputs/NoUmbrella.framework/PrivateHeaders/B_Private.h:1 {{not visible}}
 
 // Test inclusion of headers that are under an umbrella directory but
 // not actually part of the module.
-#include <Module/NotInModule.h> // expected-warning{{treating #include as an import of module 'Module.NotInModule'}} \
+#include <Module/NotInModule.h> // expected-remark{{treating #include as an import of module 'Module.NotInModule'}} \
   // expected-warning{{missing submodule 'Module.NotInModule'}}
 
 int getNotInModule(void) {
   return not_in_module;
 }
 
 void includeNotAtTopLevel(void) { // expected-note {{function 'includeNotAtTopLevel' begins here}}
-  #include <NoUmbrella/A.h> // expected-warning {{treating #include as an import}} \
+  #include <NoUmbrella/A.h> // expected-remark {{treating #include as an import}} \
              expected-error {{redundant #include of module 'NoUmbrella.A' appears within function 'includeNotAtTopLevel'}}
 }
 
 #ifdef __cplusplus
 namespace NS { // expected-note {{begins here}}
-#include <NoUmbrella/A.h> // expected-warning {{treating #include as an import}} \
+#include <NoUmbrella/A.h> // expected-remark {{treating #include as an import}} \
                              expected-error {{redundant #include of module 'NoUmbrella.A' appears within namespace 'NS'}}
 }
 extern "C" { // expected-note {{begins here}}
-#include <NoUmbrella/A.h> // expected-warning {{treating #include as an import}} \
+#include <NoUmbrella/A.h> // expected-remark {{treating #include as an import}} \
                              expected-error {{import of C++ module 'NoUmbrella.A' appears within extern "C"}}
 }
 #endif

clang/test/Modules/conflicts.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/Conflicts %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -I %S/Inputs/Conflicts %s -verify
 
 @import Conflicts;
 
 @import Conflicts.A; // expected-warning{{module 'Conflicts.A' conflicts with already-imported module 'Conflicts.B': we just don't like B}}
 

clang/test/Modules/cxx20-include-translation.cpp

 // RUN: rm -rf %t
 // RUN: mkdir -p %t
 // RUN: split-file %s %t
 // RUN: cd %t
 //
 // RUN: %clang_cc1 -std=c++20 -xc++-user-header h1.h -emit-header-unit -o h1.pcm
 // RUN: %clang_cc1 -std=c++20 -xc++-user-header h2.h -emit-header-unit -o h2.pcm
 // RUN: %clang_cc1 -std=c++20 -xc++-user-header h3.h -emit-header-unit -o h3.pcm
 // RUN: %clang_cc1 -std=c++20 -xc++-user-header h4.h -emit-header-unit -o h4.pcm
 
 // RUN: %clang_cc1 -std=c++20 Xlate.cpp -emit-module-interface -o Xlate.pcm \
 // RUN: -fmodule-file=h1.pcm -fmodule-file=h2.pcm -fmodule-file=h3.pcm \
-// RUN: -fmodule-file=h4.pcm -fsyntax-only -Wauto-import -verify
+// RUN: -fmodule-file=h4.pcm -fsyntax-only -Rmodule-include-translation -verify
 
 // Check that we do the intended translation and not more.
 // RUN: %clang_cc1 -std=c++20 Xlate.cpp \
 // RUN: -fmodule-file=h1.pcm -fmodule-file=h2.pcm -fmodule-file=h3.pcm \
 // RUN: -fmodule-file=h4.pcm  -E -undef | FileCheck %s
 
 // We expect no diagnostics here, the used functions should all be available.
 // RUN: %clang_cc1 -std=c++20 Xlate.cpp -emit-module-interface \

 #endif // H4_GUARD
 
 //--- Xlate.cpp
 /* some comment ...
   ... */
 module /*nothing here*/;
 
 // This should be include-translated, when the header unit for h1 is available.
-#include "h1.h" // expected-warning {{treating #include as an import of module './h1.h'}}
+#include "h1.h" // expected-remark {{treating #include as an import of module './h1.h'}}
 // Import of a header unit is allowed, named modules are not.
 import "h2.h";
 // A regular, untranslated, header
 #include "h5.h"
 
 export module Xlate;
 
 // This is OK, the import immediately follows the module decl.

clang/test/Modules/framework-name.m

 // REQUIRES: shell
 // RUN: rm -rf %t.mcp %t
 // RUN: mkdir -p %t
 // RUN: ln -s %S/Inputs/NameInDir2.framework %t/NameInImport.framework
 // RUN: ln -s %S/Inputs/NameInDirInferred.framework %t/NameInImportInferred.framework
-// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fimplicit-module-maps -I %S/Inputs -F %S/Inputs -F %t -Wauto-import -verify %s
+// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t.mcp -fimplicit-module-maps -I %S/Inputs -F %S/Inputs -F %t -Rmodule-include-translation -verify %s
 
 // Verify that we won't somehow find non-canonical module names or modules where
 // we shouldn't search the framework.
-// RUN: echo '@import NameInModMap;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s
-// RUN: echo '@import NameInDir;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s
-// RUN: echo '@import NameInImport;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s
-// RUN: echo '@import NameInImportInferred;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Wauto-import -x objective-c - 2>&1 | FileCheck %s
+// RUN: echo '@import NameInModMap;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Rmodule-include-translation -x objective-c - 2>&1 | FileCheck %s
+// RUN: echo '@import NameInDir;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Rmodule-include-translation -x objective-c - 2>&1 | FileCheck %s
+// RUN: echo '@import NameInImport;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Rmodule-include-translation -x objective-c - 2>&1 | FileCheck %s
+// RUN: echo '@import NameInImportInferred;' | not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t.mcp -F %S/Inputs -F %t -Rmodule-include-translation -x objective-c - 2>&1 | FileCheck %s
 // CHECK: module '{{.*}}' not found
 
 // FIXME: We might want to someday lock down framework modules so that these
 // name mismatches are disallowed. However, as long as we *don't* prevent them
 // it's important that they map correctly to module imports.
 
 // The module map name doesn't match the directory name.
-#import <NameInDir/NameInDir.h> // expected-warning {{import of module 'NameInModMap'}}
+#import <NameInDir/NameInDir.h> // expected-remark {{import of module 'NameInModMap'}}
 
 // The name in the import doesn't match the module name.
-#import <NameInImport/NameInDir2.h> // expected-warning {{import of module 'NameInDir2'}}
+#import <NameInImport/NameInDir2.h> // expected-remark {{import of module 'NameInDir2'}}
 @import NameInDir2;                 // OK
 
 // The name in the import doesn't match the module name (inferred framework module).
-#import <NameInImportInferred/NameInDirInferred.h> // expected-warning {{import of module 'NameInDirInferred'}}
+#import <NameInImportInferred/NameInDirInferred.h> // expected-remark {{import of module 'NameInDirInferred'}}
 
 @import ImportNameInDir;
 #ifdef NAME_IN_DIR
 #error NAME_IN_DIR should be undef'd
 #endif

clang/test/Modules/global_index.m

 // RUN: rm -rf %t
 // Run without global module index
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -fno-modules-global-index -F %S/Inputs %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -fno-modules-global-index -F %S/Inputs %s -verify
 // RUN: ls %t|not grep modules.idx
 // Run and create the global module index
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
 // RUN: ls %t|grep modules.idx
 // Run and use the global module index
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -print-stats 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fdisable-module-hash -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify -print-stats 2>&1 | FileCheck %s
 
 // expected-no-diagnostics
 @import DependsOnModule;
 @import Module;
 
 // CHECK: *** Global Module Index Statistics:
 
 int *get_sub(void) {
   return Module_Sub;
 }

clang/test/Modules/implementation-of-module.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=auto-import %s -I %S/Inputs \
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-include-translation %s -I %S/Inputs \
 // RUN:     -fmodule-implementation-of category_right -fsyntax-only
 
-// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=auto-import %s -I %S/Inputs \
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-include-translation %s -I %S/Inputs \
 // RUN:     -fmodule-implementation-of category_right -dM -E -o - 2>&1 | FileCheck %s
 // CHECK-NOT: __building_module
 
-// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=auto-import %s -I %S/Inputs \
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-include-translation %s -I %S/Inputs \
 // RUN:     -fmodule-implementation-of category_left -verify
 
-// RUN: %clang_cc1 -x objective-c-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=auto-import %s -I %S/Inputs \
+// RUN: %clang_cc1 -x objective-c-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-include-translation %s -I %S/Inputs \
 // RUN:     -fmodule-implementation-of category_right -emit-pch -o %t.pch
-// RUN: %clang_cc1 -x objective-c-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Werror=auto-import %s -I %S/Inputs \
+// RUN: %clang_cc1 -x objective-c-header -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -Rmodule-include-translation %s -I %S/Inputs \
 // RUN:     -DWITH_PREFIX -fmodules-ignore-macro=WITH_PREFIX -include-pch %t.pch -fmodule-implementation-of category_right
 
 #ifndef WITH_PREFIX
 
 @import category_left; // expected-error{{@import of module 'category_left' in implementation of 'category_left'; use #import}}
 @import category_left.sub; // expected-error{{@import of module 'category_left.sub' in implementation of 'category_left'; use #import}}
-#import "category_right.h" // expected-error{{treating}}
-#import "category_right_sub.h" // expected-error{{treating}}
+#import "category_right.h" // expected-remark{{treating}}
+#import "category_right_sub.h" // expected-remark{{treating}}
 
 #endif
 

clang/test/Modules/inferred-frameworks.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x objective-c -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
+// RUN: %clang_cc1 -x objective-c -Rmodule-include-translation -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
 
 #include <NotAModule/NotAModule.h>
 
 @import NotAModule; // expected-error{{module 'NotAModule' not found}}
 
 

clang/test/Modules/inferred-submodules.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x objective-c -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
+// RUN: %clang_cc1 -x objective-c -Rmodule-include-translation -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
 // expected-no-diagnostics
 
 @import Module.Sub;
 
 void test_Module_Sub(void) {
   int *ip = Module_Sub;
 }
 
 @import Module.Buried.Treasure;
 
 void dig(void) {
   unsigned *up = Buried_Treasure;
 }
 

clang/test/Modules/requires.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs %s -verify -fmodule-feature custom_req1
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs %s -verify -std=c89 -DTEST_C_FEATURES
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs %s -verify -fmodule-feature custom_req1
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs %s -verify -std=c89 -DTEST_C_FEATURES
 #ifndef TEST_C_FEATURES
 // [e-mail]/module.map:7 {{module 'DependsOnModule.CXX' requires feature 'cplusplus'}}
 @import DependsOnModule.CXX; // expected-note {{module imported here}}
 @import DependsOnModule.NotCXX;
 // [e-mail]/module.map:15 {{module 'DependsOnModule.NotObjC' is incompatible with feature 'objc'}}
 @import DependsOnModule.NotObjC; // expected-note {{module imported here}}
 @import DependsOnModule.CustomReq1; // OK
 // [e-mail]/module.map:22 {{module 'DependsOnModule.CustomReq2' requires feature 'custom_req2'}}

clang/test/Modules/requires.mm

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs/DependsOnModule.framework %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -I %S/Inputs/DependsOnModule.framework %s -verify
 
 @import DependsOnModule.CXX;
 // [e-mail]:11 {{module 'DependsOnModule.NotCXX' is incompatible with feature 'cplusplus'}}
 @import DependsOnModule.NotCXX; // expected-note {{module imported here}}
 // [e-mail]:15 {{module 'DependsOnModule.NotObjC' is incompatible with feature 'objc'}}
 @import DependsOnModule.NotObjC; // expected-note {{module imported here}}

clang/test/Modules/resolution-change.m

 // RUN: rm -rf %t
 
 // Build PCH using A from path 1
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -emit-pch -o %t-A.pch %s
 
 // Use the PCH with the same header search options; should be fine
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -include-pch %t-A.pch %s -fsyntax-only -Werror
 
 // Different -W options are ok
-// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -include-pch %t-A.pch %s -fsyntax-only -Werror -Wauto-import
+// RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -I %S/Inputs/modules-with-same-name/path1/A -include-pch %t-A.pch %s -fsyntax-only -Werror -Rmodule-include-translation
 
 // Use the PCH with no way to resolve DependsOnA
 // RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NODOA %s
 // CHECK-NODOA: module 'DependsOnA' in AST file '{{.*DependsOnA.*pcm}}' (imported by AST file '{{.*A.pch}}') is not defined in any loaded module map
 
 // Use the PCH with no way to resolve A
 // RUN: not %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs/modules-with-same-name/DependsOnA -include-pch %t-A.pch %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CHECK-NOA %s
 // CHECK-NOA: module 'A' in AST file '{{.*A.*pcm}}' (imported by AST file '{{.*DependsOnA.*pcm}}') is not defined in any loaded module map

clang/test/Modules/subframeworks.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify
-// RUN: %clang_cc1 -x objective-c++ -Wauto-import -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify
+// RUN: %clang_cc1 -x objective-c++ -Rmodule-include-translation -Wno-private-module -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs -F %S/Inputs/DependsOnModule.framework/Frameworks %s -verify
 
 @import DependsOnModule;
 
 void testSubFramework(void) {
   float *sf1 = sub_framework; // expected-error{{declaration of 'sub_framework' must be imported from module 'DependsOnModule.SubFramework' before it is required}}
   // expected-note@Inputs/DependsOnModule.framework/Frameworks/SubFramework.framework/Headers/SubFramework.h:2 {{here}}
 }
 
 @import DependsOnModule.SubFramework;
 
 void testSubFrameworkAgain(void) {
   float *sf2 = sub_framework;
   double *sfo1 = sub_framework_other;
 }
 
 #ifdef __cplusplus
 @import DependsOnModule.CXX;
 
 CXXOnly cxxonly;
 #endif
 
 @import HasSubModules;
 
-// expected-warning@Inputs/HasSubModules.framework/Frameworks/Sub.framework/PrivateHeaders/SubPriv.h:1{{treating #include as an import of module 'HasSubModules.Sub.Types'}}
+// expected-remark@Inputs/HasSubModules.framework/Frameworks/Sub.framework/PrivateHeaders/SubPriv.h:1{{treating #include as an import of module 'HasSubModules.Sub.Types'}}
 #import <HasSubModules/HasSubModulesPriv.h>
 
 struct FrameworkSubStruct ss;

clang/test/Modules/submodules.m

 
 // RUN: rm -rf %t
-// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
+// RUN: %clang_cc1 -Rmodule-include-translation -fmodules-cache-path=%t -fmodules -fimplicit-module-maps -F %S/Inputs %s -verify
 // expected-no-diagnostics
 
 // Note: transitively imports Module.Sub2.
 @import Module.Sub;
 
 int getValue(void) { 
   return *Module_Sub + *Module_Sub2;
 }
 

clang/test/VFS/real-path-found-first.m

 // This test is for cases where we lookup a file by its 'real' path before we
 // use its VFS-mapped path. If we accidentally use the real path in header
 // search, we will not find a module for the headers.  To test that we
 // intentionally rebuild modules, since the precompiled module file refers to
 // the dependency files by real path.
 
 // RUN: rm -rf %t %t-cache %t.pch
 // RUN: mkdir -p %t/SomeFramework.framework/Modules
 // RUN: cat %S/Inputs/some_frame_module.map > %t/SomeFramework.framework/Modules/module.modulemap
 // RUN: sed -e "s@INPUT_DIR@%{/S:regex_replacement}/Inputs@g" -e "s@OUT_DIR@%{/t:regex_replacement}@g" %S/Inputs/vfsoverlay.yaml > %t.yaml
 
 // Build
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
-// RUN:     -ivfsoverlay %t.yaml -fsyntax-only %s -verify -Wauto-import \
+// RUN:     -ivfsoverlay %t.yaml -fsyntax-only %s -verify -Rmodule-include-translation \
 // RUN:     -Werror=non-modular-include-in-framework-module
 
 // Rebuild
 // RUN: echo ' ' >> %t/SomeFramework.framework/Modules/module.modulemap
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
-// RUN:     -ivfsoverlay %t.yaml -fsyntax-only %s -verify -Wauto-import \
+// RUN:     -ivfsoverlay %t.yaml -fsyntax-only %s -verify -Rmodule-include-translation \
 // RUN:     -Werror=non-modular-include-in-framework-module
 
 // Load from PCH
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
 // RUN:     -ivfsoverlay %t.yaml -emit-pch  %s -o %t.pch \
 // RUN:     -Werror=non-modular-include-in-framework-module \
 // RUN:     -fmodules-ignore-macro=WITH_PREFIX
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
 // RUN:     -ivfsoverlay %t.yaml -include-pch %t.pch -fsyntax-only  %s \
 // RUN:     -Werror=non-modular-include-in-framework-module -DWITH_PREFIX \
 // RUN:     -fmodules-ignore-macro=WITH_PREFIX
 
 // While indexing
 // RUN: c-index-test -index-file %s -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
-// RUN:     -ivfsoverlay %t.yaml -fsyntax-only -Wauto-import \
+// RUN:     -ivfsoverlay %t.yaml -fsyntax-only -Rmodule-include-translation \
 // RUN:     -Werror=non-modular-include-in-framework-module | FileCheck %s
 // RUN: echo ' ' >> %t/SomeFramework.framework/Modules/module.modulemap
 // RUN: c-index-test -index-file %s -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
-// RUN:     -ivfsoverlay %t.yaml -fsyntax-only -Wauto-import \
+// RUN:     -ivfsoverlay %t.yaml -fsyntax-only -Rmodule-include-translation \
 // RUN:     -Werror=non-modular-include-in-framework-module | FileCheck %s
 // CHECK: warning: treating
 // CHECK-NOT: error
 
 // With a VFS-mapped module map file
 // RUN: mv %t/SomeFramework.framework/Modules/module.modulemap %t/hide_module.map
 // RUN: echo "{ 'version': 0, 'roots': [ { " > %t2.yaml
 // RUN: echo "'name': '%t/SomeFramework.framework/Modules/module.modulemap'," >> %t2.yaml
 // RUN: echo "'type': 'file', 'external-contents': '%t/hide_module.map' } ] }" >> %t2.yaml
 
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
 // RUN:     -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only %s -verify \
-// RUN:     -Wauto-import -Werror=non-modular-include-in-framework-module
+// RUN:     -Rmodule-include-translation -Werror=non-modular-include-in-framework-module
 // RUN: echo ' ' >> %t/hide_module.map
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
 // RUN:     -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only %s -verify \
-// RUN:     -Wauto-import -Werror=non-modular-include-in-framework-module
+// RUN:     -Rmodule-include-translation -Werror=non-modular-include-in-framework-module
 
 // Within a module build
 // RUN: echo '@import import_some_frame;' | \
 // RUN:   %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
 // RUN:      -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only - \
 // RUN:      -Werror=non-modular-include-in-framework-module -x objective-c -I %t
 // RUN: echo ' ' >> %t/hide_module.map
 // RUN: echo '@import import_some_frame;' | \
 // RUN:   %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t-cache -F %t \
 // RUN:      -ivfsoverlay %t.yaml -ivfsoverlay %t2.yaml -fsyntax-only - \
 // RUN:      -Werror=non-modular-include-in-framework-module -x objective-c -I %t
 
 #ifndef WITH_PREFIX
-#import <SomeFramework/public_header.h> // expected-warning{{treating}}
-#import <SomeFramework/public_header2.h> // expected-warning{{treating}}
-#import <SomeFramework/public_header3.h> // expected-warning{{treating}}
+#import <SomeFramework/public_header.h> // expected-remark{{treating}}
+#import <SomeFramework/public_header2.h> // expected-remark{{treating}}
+#import <SomeFramework/public_header3.h> // expected-remark{{treating}}
 @import SomeFramework.public_header2;
 #endif