preview patch for fixit for finding modules needing import/inclusion

[jtsoftware]

Summary

This is the beginnings of a patch to add a fixit for automatically loading a module to resolve a type or symbol reference and outputting a fixit message.

I wanted to get some early feedback to make sure I'm on the right path, and also some answers for questions about a couple of difficult areas.

A problematic part is that the global module index seems to only include modules that have been imported before, and has not necessarily already been created or loaded yet. To handle this, I added a loadGlobalModuleIndex to ModuleLoader that will create the module index if it doesn't yet exist, and will walk the top level modules in the module map and load any modules not already loaded (it will load them as hidden), for the side effect of loading the global module index with identifiers from all the modules. This might involves two calls to create the index, as I can't compare it against the module map unless I have an index already. This is one area I need feedback from someone who knows the module system, as there might be a better way. I suppose we don't create a full index right off, because of the performance cost.

Then, in Sema I added a getTypeNameWithModuleCheck function to be used instead of getTypeName, which, if the type is not found, will do the load global index check, look up in the index any modules with the type identifier, and if found, make the module visible, redo the type search, and if found, display the fixit and continue. If the type is not found, the module is made hidden again.

Another probable problem with this scheme is that apparently only top-level modules correspond to a module AST file, and the global module index only lists those top-level modules. Is there code somewhere to find the module a symbol belongs to such that I can just make that module visible?

There's some other FIXME's in the code, such as one for figuring out the SourceLocation for where to put the fixit. Any suggestions?

Perhaps the fixit message itself needs some revision, I just took a stab at it, as I wanted to get something out for feedback.

I added -fmodules-search-all and -fno-modules-search-all to enable or disable this (enabed by default). I also added a need-import warning group.

This affected a few of the Modules tests. I punted on it by just added a -fno-modules-search-all option to their command lines.

I added one new bare-bones test for this fixit, in test/Modules/undefined-type-fixit1.cpp. More needs to be done to it to check the various scenarios of the global module index existing.

Because of the addition of an abstract function to ModuleLoader, I needed to put a stub for it in some unit tests that derive from it.

The formatting might be a bit spotty, as the focus here is to get some early feedback.

When and if this fixit and the infrastructure is good enough, then I can find other places to do similar fixit's for resolving identifiers.

Thanks.

-John

[rsmith]

include/clang/Sema/Sema.h

1326–1328

I'm not fond of this approach -- we'll end up with these WithModuleCheck functions scattered throughout various places that perform name lookup, with lots of duplication.

The existing recovery for missing imports is performed in Sema::CorrectTypo; I would suggest putting the new functionality there too. Perhaps if typo correction fails to find a result using its normal resolution mechanism, you could pull in all the modules that the global index is aware of, and try again?

lib/Lex/HeaderSearch.cpp

697–706

I'd like for this to be split out into a separate change. I also find this a little surprising, so I'd like an explanation of why this is the appropriate thing to do. If we're using -I-, we should probably still look for the contents of a module relative to the module. If this is fixing the bug I think it's fixing, I think the problem is that we put the wrong paths into the synthetic file containing #includes, and fixing it there would be better.

[jtsoftware]

I've reworked this to do the check in CorrectTypo as suggested. This is just a partial post, as I've omitted needed changes to other tests so we can focus on the key parts. I basically would like to know if this is the right approach, and what needs to be done to make it right/better.

Question: I saw that there was some code for handling missing imports, but I couldn't see where it searched the global module index, and my new test case (with the new code disabled) didn't trigger it. Was it just for some special cases?

Thanks.

-John

[rsmith]

This looks like basically the right approach to me.

lib/Frontend/CompilerInstance.cpp

41

It looks like this will build every module described in any module map we've loaded. That could be extremely time-consuming, and could produce errors. Is that what you want here?

lib/Sema/SemaLookup.cpp

4060–4061 ↗

(On Diff #8146)

We should probably only do this if we got to the end of typo-correction and found no corrections.

4096–4098 ↗

(On Diff #8146)

This won't work. We don't support visibility decreasing. Instead, you should be able to just load the module rather than making it visible, and tell your LookupResult to find hidden results during the lookup.

lib/Serialization/GlobalModuleIndex.cpp

16–29

Feel free to just check this part in.

[jtsoftware]

I added a BuildingModule flag to ModuleLoader so I could avoid doing the correctTypo modules import fixit or global module index rebuild when a module is being built.

I merged the prior need import error message into a single warning.

I hack the test/Modules tests to accomodate the new error, and to disable the modules import fixit for tests that trigger an index rebuild involving the test/Modules/module.map file, as some modules have build errors that get triggered.

I didn't do anything with respect to the issue of not displaying error messages during a module build, leaving it for a separate fix.

Is this ready to check in?

Thanks.

-John

[rsmith]

include/clang/Basic/DiagnosticSemaKinds.td

6961–6963

This shouldn't be a Warning. If we really want to allow this as an extension (and I don't see why we should), it should be an ExtWarn, and should be DefaultError.

include/clang/Driver/Options.td

671–673

Only the non-default value of the flag should have HelpText.

include/clang/Frontend/CompilerInstance.h

154

This constructor should be explicit.

Also, just BuildingModule, not BuildingModuleFlag.

lib/Frontend/CompilerInstance.cpp

857

Instance(/*BuildingModule=*/true); would be more obvious.

1427

Do we need to take any other steps to ensure we've actually loaded all the modulemap files that are within our include paths?

lib/Frontend/CompilerInvocation.cpp

1347–1349

I think this should default to off. It still makes diagnostics non-reproducible (because it depends on what other modules happen to be in the global index at the point when we perform typo correction), and may have a *very* significant runtime penalty if we hit a diagnostic.

lib/Sema/SemaDecl.cpp

10072

I really don't like this collection of unexplained mystery arguments (repeating the default arguments for all but the last).

Maybe move the error recovery flag earlier, and change it to an enum class so its values can have more obvious names (and won't accidentally convert to bool)?

lib/Sema/SemaLookup.cpp

4067 ↗

(On Diff #8275)

&& should go on the previous line.

4075–4109 ↗

(On Diff #8275)

I think this is all unnecessary; just make sure we've loaded all the modules that contain the identifier, and let the normal recovery for an invisible name do the rest.

4101–4102 ↗

(On Diff #8275)

You can't put the genie back in the bottle: once a module is unhidden, hiding it again doesn't work.

4693–4694 ↗

(On Diff #8275)

This is not a correct fixit.

4696–4697 ↗

(On Diff #8275)

This is also not OK. Please take out this fixit code for now; that's essentially orthogonal and we can deal with it as a separate change.

lib/Serialization/GlobalModuleIndex.cpp

345–358

Please commit this as a separate change.

[• tpoechtrager]

Richard,

If we really want to allow this as an extension (and I don't see why we should), it should be an ExtWarn, and should be DefaultError.

Do mean you're pretty much against this fixit, I suppose because of the performance impact when it kicks in?

-John

[jtsoftware]

Here's another crack at it, per the review changes, except for checking to see if all module maps in the search paths are loaded, which I can address later. Basically, I reverted back to the original error messages, reduced the symbol lookup to let the latter code handle it. I left in the global module index search so that those symbols found would get precedence over the normal typo checks. This option needs to be enabled via the -fmodules-search-all option. Is this the correct classification of the message, as errors?

[rsmith]

I have quite a few comments, but they're just typographical issues and things that can be deferred to later patches; this looks more-or-less ready to go.

Please also add a paragraph or so to docs/Modules.rst explaining this flag and what it does.

include/clang/Sema/Sema.h

2603

No need for abbreviation here; CorrectTypoKind would be preferred.

2604

The usual convention is to form an initialism from the name of the enum, then add underscore then enumerator names. If this enum is named CorrectTypoKind, these'd be CTK_NonError and CTK_ErrorRecovery.

lib/Frontend/CompilerInstance.cpp

836

Please use (/*BuildingModule=*/true) here.

1438

I assume this means that -fmodules-search-all won't search all modules if we see an error while building a module? (That's fine, but it's probably worth putting this into the documentation, at least.)

1439

This will only cover module.modulemap files that have already been found and loaded. That seems fine (we don't really want to go trawling the file system looking for them), but again, it's something to be aware of.

1440

Name this RecreateIndex, per the coding standard.

1446

This is unused; please remove.

1448–1450

The ModuleMap iterators will only give you top-level modules, so you don't need this loop.

1450

The SourceLocation you're using here doesn't make much sense to me. Maybe you could pass a location into this function (the location at which we're performing the typo correction)?

1451

This line is too indented; it looks like it was intended to be part of the for loop, even though it wasn't.

1453

It'd be useful to have some way to tell loadModule to suppress diagnostics from the submodule build (and to not leave a file behind if building it failed, so that later imports will try to build it again and get the diagnostics).

That can wait for a later patch, though.

1454

Please indent this to line up with the character after the (.

lib/Sema/SemaLookup.cpp

26–28 ↗

(On Diff #8657)

We generally try to keep Sema from using Lex headers. More on how you might approach this below.

4063–4086 ↗

(On Diff #8657)

I feel that this could be layered better (it seems like Sema should have a callback that CompilerInvocation fills in with this code), but again, I'm OK with that being deferred to a later patch.

4163–4164 ↗

(On Diff #8657)

We deliberately don't do this for the current code to search unimported submodules -- we assume that it's not very likely that a name is both mistyped and from an unimported module. See TypoCorrectionConsumer::FoundDecl.

For the unimported top-level module case, this would also defeat the desire to use the global index to minimize the number of modules we search, so I think we have convincing reasons to not attempt this.

[jtsoftware]

Committed in r206977 (plus fixes r206981 r207011).

include/clang/Basic/DiagnosticSemaKinds.td

6961–6963

Richard, does this mean you're pretty much against this, probably because of the performance hit if it kicks in?

lib/Frontend/CompilerInstance.cpp

1427

I don't know. I'll have to dig into it, as I just assumed they were all loaded. Can I address this later?

[jtsoftware]

Committed in r206977 (plus fixes r206981 r207011).

[jtsoftware]

Sorry, I was too aggressive in cleaning out my Phabricator list, and closed this one by mistake. Though I did an initial check-in of it, I'm still working on a couple of the review issues Richard said could be postponed to a later check-in.

-John

include/clang/Basic/DiagnosticGroups.td

 def CXX11LongLong : DiagGroup<"c++11-long-long">;
 def LongLong : DiagGroup<"long-long", [CXX11LongLong]>;
 def MethodSignatures : DiagGroup<"method-signatures">;
 def MismatchedParameterTypes : DiagGroup<"mismatched-parameter-types">;
 def MismatchedReturnTypes : DiagGroup<"mismatched-return-types">;
 def MismatchedTags : DiagGroup<"mismatched-tags">;
 def MissingFieldInitializers : DiagGroup<"missing-field-initializers">;
 def ModuleConflict : DiagGroup<"module-conflict">;
+def NeedImport : DiagGroup<"need-import">;
 def NewlineEOF : DiagGroup<"newline-eof">;
 def NullArithmetic : DiagGroup<"null-arithmetic">;
 def NullCharacter : DiagGroup<"null-character">;
 def NullDereference : DiagGroup<"null-dereference">;
 def InitializerOverrides : DiagGroup<"initializer-overrides">;
 def NonNull : DiagGroup<"nonnull">;
 def NonPODVarargs : DiagGroup<"non-pod-varargs">;
 def : DiagGroup<"nonportable-cfstrings">;

include/clang/Basic/DiagnosticSemaKinds.td

def err_module_private_local : Error<
   "__module_private__">;
 def err_module_private_local_class : Error<
   "local %select{struct|interface|union|class|enum}0 cannot be declared "
   "__module_private__">;
 def err_module_private_declaration : Error<
   "declaration of %0 must be imported from module '%1' before it is required">;
 def err_module_private_definition : Error<
   "definition of %0 must be imported from module '%1' before it is required">;
+def warn_need_module_import : Warning<
+  "use of identifier '%0' requires import/inclusion of the module '%1'">,
+  InGroup<NeedImport>;
 }
 
 let CategoryName = "Documentation Issue" in {
 def warn_not_a_doxygen_trailing_member_comment : Warning<
   "not a Doxygen trailing comment">, InGroup<Documentation>, DefaultIgnore;
 } // end of documentation issue category
 
 } // end of sema component.

include/clang/Basic/LangOptions.def

 BENIGN_LANGOPT(ThreadsafeStatics , 1, 1, "thread-safe static initializers")
 LANGOPT(POSIXThreads      , 1, 0, "POSIX thread support")
 LANGOPT(Blocks            , 1, 0, "blocks extension to C")
 BENIGN_LANGOPT(EmitAllDecls      , 1, 0, "support for emitting all declarations")
 LANGOPT(MathErrno         , 1, 1, "errno support for math functions")
 BENIGN_LANGOPT(HeinousExtensions , 1, 0, "Extensions that we really don't like and may be ripped out at any time")
 LANGOPT(Modules           , 1, 0, "modules extension to C")
 LANGOPT(ModulesDeclUse    , 1, 0, "require declaration of module uses")
+LANGOPT(ModulesSearchAll  , 1, 1, "search even non-imported modules to find unresolved references")
 LANGOPT(Optimize          , 1, 0, "__OPTIMIZE__ predefined macro")
 LANGOPT(OptimizeSize      , 1, 0, "__OPTIMIZE_SIZE__ predefined macro")
 LANGOPT(Static            , 1, 0, "__STATIC__ predefined macro (as opposed to __DYNAMIC__)")
 VALUE_LANGOPT(PackStruct  , 32, 0,
               "default struct packing maximum alignment")
 VALUE_LANGOPT(PICLevel    , 2, 0, "__PIC__ level")
 VALUE_LANGOPT(PIELevel    , 2, 0, "__PIE__ level")
 LANGOPT(GNUInline         , 1, 0, "GNU inline semantics")

include/clang/Driver/Options.td

def fmodules_cache_path : Joined<["-"], "fmodules-cache-path=">, Group<i_Group>,
   Flags<[DriverOption, CC1Option]>, MetaVarName<"<directory>">,
   HelpText<"Specify the module cache path">;
 def fmodules_prune_interval : Joined<["-"], "fmodules-prune-interval=">, Group<i_Group>,
   Flags<[CC1Option]>, MetaVarName<"<seconds>">,
   HelpText<"Specify the interval (in seconds) between attempts to prune the module cache">;
 def fmodules_prune_after : Joined<["-"], "fmodules-prune-after=">, Group<i_Group>,
   Flags<[CC1Option]>, MetaVarName<"<seconds>">,
   HelpText<"Specify the interval (in seconds) after which a module file will be considered unused">;
+def fmodules_search_all : Flag <["-"], "fmodules-search-all">, Group<f_Group>,
+  Flags<[DriverOption, CC1Option]>,
+  HelpText<"Search even non-imported modules to resolve references">;
 def fmodules : Flag <["-"], "fmodules">, Group<f_Group>,
   Flags<[DriverOption, CC1Option]>,
   HelpText<"Enable the 'modules' language feature">;
 def fmodule_maps : Flag <["-"], "fmodule-maps">, Group<f_Group>,
   Flags<[DriverOption,CC1Option]>,
   HelpText<"Read module maps to understand the structure of library headers">;
 def fmodule_name : JoinedOrSeparate<["-"], "fmodule-name=">, Group<f_Group>,
   Flags<[DriverOption,CC1Option]>, MetaVarName<"<name>">,

 def fno_merge_all_constants : Flag<["-"], "fno-merge-all-constants">, Group<f_Group>,
     Flags<[CC1Option]>, HelpText<"Disallow merging of constants">;
 def fno_modules : Flag <["-"], "fno-modules">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_module_maps : Flag <["-"], "fno-module-maps">, Group<f_Group>,
   Flags<[DriverOption]>;
 def fno_modules_decluse : Flag <["-"], "fno-modules-decluse">, Group<f_Group>,
   Flags<[DriverOption]>;
+def fno_modules_search_all : Flag <["-"], "fno-modules-search-all">, Group<f_Group>,
+  Flags<[DriverOption, CC1Option]>,
+  HelpText<"Inhibit search of non-imported modules to resolve references">;
 def fno_ms_extensions : Flag<["-"], "fno-ms-extensions">, Group<f_Group>;
 def fno_ms_compatibility : Flag<["-"], "fno-ms-compatibility">, Group<f_Group>;
 def fno_delayed_template_parsing : Flag<["-"], "fno-delayed-template-parsing">, Group<f_Group>;
 def fno_objc_exceptions: Flag<["-"], "fno-objc-exceptions">, Group<f_Group>;
 def fno_objc_legacy_dispatch : Flag<["-"], "fno-objc-legacy-dispatch">, Group<f_Group>;
 def fno_omit_frame_pointer : Flag<["-"], "fno-omit-frame-pointer">, Group<f_Group>;
 def fno_operator_names : Flag<["-"], "fno-operator-names">, Group<f_Group>,
   HelpText<"Do not treat C++ operator name keywords as synonyms for operators">,
   Flags<[CC1Option]>;
 def fno_pascal_strings : Flag<["-"], "fno-pascal-strings">, Group<f_Group>;
 def fno_rtti : Flag<["-"], "fno-rtti">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Disable generation of rtti information">;
 def fno_short_enums : Flag<["-"], "fno-short-enums">, Group<f_Group>;
 def fno_show_column : Flag<["-"], "fno-show-column">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Do not include column number on diagnostics">;
 def fno_show_source_location : Flag<["-"], "fno-show-source-location">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Do not include source location information with diagnostics">;
 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Disable spell-checking">;

include/clang/Frontend/ASTUnit.h

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
     return ModuleLoadResult();
   }
 
   virtual void makeModuleVisible(Module *Mod,
                                  Module::NameVisibilityKind Visibility,
                                  SourceLocation ImportLoc,
                                  bool Complain) { }
 
+
+  GlobalModuleIndex *loadGlobalModuleIndex() { return 0; }
 };
 
 } // namespace clang
 
 #endif

include/clang/Frontend/CompilerInstance.h

class CompilerInstance : public ModuleLoader {
   /// \brief The result of the last module import.
   ///
   ModuleLoadResult LastModuleImportResult;
 
   /// \brief Whether we should (re)build the global module index once we
   /// have finished with this translation unit.
   bool BuildGlobalModuleIndex;
 
+  /// \brief We have a full global module index, with all modules.
+  bool HaveFullGlobalModuleIndex;
+
   /// \brief One or more modules failed to build.
   bool ModuleBuildFailed;
 
   /// \brief Holds information about the output file.
   ///
   /// If TempFilename is not empty we must rename it to Filename at the end.
   /// TempFilename may be empty and Filename non-empty if creating the temporary
   /// failed.
class CompilerInstance : public ModuleLoader {
   void operator=(const CompilerInstance &) LLVM_DELETED_FUNCTION;
 public:
   CompilerInstance();
   ~CompilerInstance();
 
   /// @name High-Level Operations
   /// {
 
   /// ExecuteAction - Execute the provided action against the compiler's
   /// CompilerInvocation object.
   ///
   /// This function makes the following assumptions:
   ///
   ///  - The invocation options should be initialized. This function does not
   ///    handle the '-help' or '-version' options, clients should handle those
   ///    directly.
   ///
public:
   /// \return True on success.
   static bool InitializeSourceManager(const FrontendInputFile &Input,
                 DiagnosticsEngine &Diags,
                 FileManager &FileMgr,
                 SourceManager &SourceMgr,
                 const FrontendOptions &Opts);
 
   /// }
-  
+  // Create module manager.
+  void createModuleManager();
+
   virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
                                       ModuleIdPath Path,
                                       Module::NameVisibilityKind Visibility,
                                       bool IsInclusionDirective);
 
   virtual void makeModuleVisible(Module *Mod,
                                  Module::NameVisibilityKind Visibility,
                                  SourceLocation ImportLoc,
                                  bool Complain);
 
   bool hadModuleLoaderFatalFailure() const {
     return ModuleLoader::HadFatalFailure;
   }
 
+  virtual GlobalModuleIndex *loadGlobalModuleIndex();
+
 };
 
 } // end namespace clang
 
 #endif

include/clang/Lex/HeaderSearch.h

public:
   /// \param ModuleName The name of the module we're looking for.
   ///
   /// \param AllowSearch Whether we are allowed to search in the various
   /// search directories to produce a module definition. If not, this lookup
   /// will only return an already-known module.
   ///
   /// \returns The module with the given name.
   Module *lookupModule(StringRef ModuleName, bool AllowSearch = true);
-  
+  /// \brief Lookup a top level module given its file name.
+  ///
+  /// \param ModuleFileName The name of the module file.
+  ///
+  /// \returns The module with the given name.
+  Module *lookupModuleFromFile(StringRef ModuleFileName);
+  
   void IncrementFrameworkLookupCount() { ++NumFrameworkLookups; }
 
   /// \brief Determine whether there is a module map that may map the header
   /// with the given file name to a (sub)module.
   /// Always returns false if modules are disabled.
   ///
   /// \param Filename The name of the file.
   ///

include/clang/Lex/ModuleLoader.h

 
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerIntPair.h"
 
 namespace clang {
 
+class GlobalModuleIndex;
 class IdentifierInfo;
 class Module;
 
 /// \brief A sequence of identifier/location pairs used to describe a particular
 /// module or submodule, e.g., std.vector.
 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation> > ModuleIdPath;
 
 /// \brief Describes the result of attempting to load a module.
virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
                                       bool IsInclusionDirective) = 0;
 
   /// \brief Make the given module visible.
   virtual void makeModuleVisible(Module *Mod,
                                  Module::NameVisibilityKind Visibility,
                                  SourceLocation ImportLoc,
                                  bool Complain) = 0;
 
+  /// \brief Load, create, or return global module.
+  /// This function returns an existing global module index, if one
+  /// had already been loaded or created, or loads one if it
+  /// exists, or creates one if it doesn't exist.
+  /// Also, importantly, if the index doesn't cover all the modules
+  /// in the module map, it will be update to do so here, because
+  /// of its use in searching for needed module imports and
+  /// associated fixit messages.
+  /// \returns Returns null if load failed.
+  virtual GlobalModuleIndex *loadGlobalModuleIndex() = 0;
+
   bool HadFatalFailure;
 };
   
 }
 
 #endif

include/clang/Sema/Sema.h

public:
   ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
                          Scope *S, CXXScopeSpec *SS = 0,
                          bool isClassName = false,
                          bool HasTrailingDot = false,
                          ParsedType ObjectType = ParsedType(),
                          bool IsCtorOrDtorName = false,
                          bool WantNontrivialTypeSourceInfo = false,
                          IdentifierInfo **CorrectedII = 0);
+
+  // Calls getTypeName, and if not found, will search for a module with the
+  // type, implicitly importing it and displaying a fixit message.
+  ParsedType getTypeNameWithModuleCheck(const IdentifierInfo &II,
+                         SourceLocation NameLoc,
+                         Scope *S, CXXScopeSpec *SS = 0,
+                         bool isClassName = false,
+                         bool HasTrailingDot = false,
+                         ParsedType ObjectType = ParsedType(),
+                         bool IsCtorOrDtorName = false,
+                         bool WantNontrivialTypeSourceInfo = false,
+                         IdentifierInfo **CorrectedII = 0);
   TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
   bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
   bool DiagnoseUnknownTypeName(IdentifierInfo *&II,
                                SourceLocation IILoc,
                                Scope *S,
                                CXXScopeSpec *SS,
                                ParsedType &SuggestedType);
 
public:
   void CheckAlignasUnderalignment(Decl *D);
 
   /// Adjust the calling convention of a method to be the ABI default if it
   /// wasn't specified explicitly.  This handles method types formed from
   /// function type typedefs and typename template arguments.
   void adjustMemberFunctionCC(QualType &T, bool IsStatic);
 
   // Check if there is an explicit attribute, but only look through parens.
   // The intent is to look for an attribute on the current declarator, but not
   // one that came from a typedef.
   bool hasExplicitCallingConv(QualType &T);
 
   /// Get the outermost AttributedType node that sets a calling convention.
   /// Valid types should not have multiple attributes with different CCs.
   const AttributedType *getCallingConvAttributedType(QualType T) const;
 
   /// \brief Stmt attributes - this routine is the top level dispatcher.
   StmtResult ProcessStmtAttributes(Stmt *Stmt, AttributeList *Attrs,

include/clang/Serialization/ASTReader.h

public:
   }
 
   /// \brief Set the AST deserialization listener.
   void setDeserializationListener(ASTDeserializationListener *Listener);
 
   /// \brief Determine whether this AST reader has a global index.
   bool hasGlobalIndex() const { return GlobalIndex.isValid(); }
 
+  /// \brief Return global module index.
+  GlobalModuleIndex *getGlobalIndex() { return GlobalIndex.get(); }
+
+  /// \brief Reset reader for a reload try.
+  void resetForReload() { TriedLoadingGlobalIndex = false; }
+
   /// \brief Attempts to load the global index.
   ///
   /// \returns true if loading the global index has failed for any reason.
   bool loadGlobalIndex();
 
   /// \brief Determine whether we tried to load the global index, but failed,
   /// e.g., because it is out-of-date or does not exist.
   bool isGlobalIndexUnavailable() const;

include/clang/Serialization/GlobalModuleIndex.h

public:
   ///
   /// \returns false if the global module index has information about this
   /// module file, and true otherwise.
   bool loadedModuleFile(ModuleFile *File);
 
   /// \brief Print statistics to standard error.
   void printStats();
 
+  /// \brief Print debugging view to standard error.
+  void dump();
+
   /// \brief Write a global index into the given
   ///
   /// \param FileMgr The file manager to use to load module files.
   ///
   /// \param Path The path to the directory containing module files, into
   /// which the global index will be written.
   static ErrorCode writeIndex(FileManager &FileMgr, StringRef Path);
 };
 
 }
 
 #endif

lib/Frontend/CompilerInstance.cpp

 #include "clang/Frontend/Utils.h"
 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/PTHManager.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Serialization/ASTReader.h"
+#include "clang/Serialization/GlobalModuleIndex.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/LockFileManager.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/system_error.h"
 #include <sys/stat.h>
 #include <time.h>
 
 using namespace clang;
 
 CompilerInstance::CompilerInstance()
   : Invocation(new CompilerInvocation()), ModuleManager(0),
-    BuildGlobalModuleIndex(false), ModuleBuildFailed(false) {
+    BuildGlobalModuleIndex(false), HaveFullGlobalModuleIndex(false),
+    ModuleBuildFailed(false) {
 }
 
 CompilerInstance::~CompilerInstance() {
   assert(OutputFiles.empty() && "Still output files in flight?");
 }
 
 void CompilerInstance::setInvocation(CompilerInvocation *Value) {
   Invocation = Value;
PPOpts.Macros.erase(std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
                                      RemoveIgnoredMacro(HSOpts)),
                       PPOpts.Macros.end());
 
 
   // Note the name of the module we're building.
   Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
 
   // Make sure that the failed-module structure has been allocated in
   // the importing instance, and propagate the pointer to the newly-created
   // instance.
   PreprocessorOptions &ImportingPPOpts
     = ImportingInstance.getInvocation().getPreprocessorOpts();
   if (!ImportingPPOpts.FailedModules)
     ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
   PPOpts.FailedModules = ImportingPPOpts.FailedModules;
 
   // If there is a module map file, build the module using the module map.
   // Set up the inputs/outputs so that we build the module from its umbrella
   // header.
   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
   FrontendOpts.OutputFile = ModuleFileName.str();
   FrontendOpts.DisableFree = false;
   FrontendOpts.GenerateGlobalModuleIndex = false;
   FrontendOpts.Inputs.clear();
   InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
 
   // Don't free the remapped file buffers; they are owned by our caller.
   PPOpts.RetainRemappedFileBuffers = true;
     
   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
   assert(ImportingInstance.getInvocation().getModuleHash() ==
          Invocation->getModuleHash() && "Module hash mismatch!");
   
   // Construct a compiler instance that will be used to actually create the
   // module.
   CompilerInstance Instance;
   Instance.setInvocation(&*Invocation);
 
for (llvm::sys::fs::directory_iterator
 
     // If we removed all of the files in the directory, remove the directory
     // itself.
     if (RemovedAllFiles)
       llvm::sys::fs::remove(Dir->path());
   }
 }
 
+void CompilerInstance::createModuleManager() {
+  if (!ModuleManager) {
+    if (!hasASTContext())
+      createASTContext();
+
+    // If we're not recursively building a module, check whether we
+    // need to prune the module cache.
+    if (getSourceManager().getModuleBuildStack().empty() &&
+        getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
+        getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
+      pruneModuleCache(getHeaderSearchOpts());
+    }
+
+    std::string Sysroot = getHeaderSearchOpts().Sysroot;
+    const PreprocessorOptions &PPOpts = getPreprocessorOpts();
+    ModuleManager = new ASTReader(getPreprocessor(), *Context,
+                                  Sysroot.empty() ? "" : Sysroot.c_str(),
+                                  PPOpts.DisablePCHValidation,
+                                  /*AllowASTWithCompilerErrors=*/false,
+                                  getFrontendOpts().UseGlobalModuleIndex);
+    if (hasASTConsumer()) {
+      ModuleManager->setDeserializationListener(
+        getASTConsumer().GetASTDeserializationListener());
+      getASTContext().setASTMutationListener(
+        getASTConsumer().GetASTMutationListener());
+    }
+
+    OwningPtr<ExternalASTSource> Source;
+    Source.reset(ModuleManager);
+    getASTContext().setExternalSource(Source);
+    if (hasSema())
+      ModuleManager->InitializeSema(getSema());
+    if (hasASTConsumer())
+      ModuleManager->StartTranslationUnit(&getASTConsumer());
+  }
+}
+
 ModuleLoadResult
 CompilerInstance::loadModule(SourceLocation ImportLoc,
                              ModuleIdPath Path,
                              Module::NameVisibilityKind Visibility,
                              bool IsInclusionDirective) {
   // Determine what file we're searching from.
   StringRef ModuleName = Path[0].first->getName();
   SourceLocation ModuleNameLoc = Path[0].second;
if (!Module) {
       ModuleBuildFailed = true;
       return ModuleLoadResult();
     }
 
     std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
 
     // If we don't already have an ASTReader, create one now.
     if (!ModuleManager) {
-      if (!hasASTContext())
-        createASTContext();
-
-      // If we're not recursively building a module, check whether we
-      // need to prune the module cache.
-      if (getSourceManager().getModuleBuildStack().empty() &&
-          getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
-          getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
-        pruneModuleCache(getHeaderSearchOpts());
-      }
-
-      std::string Sysroot = getHeaderSearchOpts().Sysroot;
-      const PreprocessorOptions &PPOpts = getPreprocessorOpts();
-      ModuleManager = new ASTReader(getPreprocessor(), *Context,
-                                    Sysroot.empty() ? "" : Sysroot.c_str(),
-                                    PPOpts.DisablePCHValidation,
-                                    /*AllowASTWithCompilerErrors=*/false,
-                                    getFrontendOpts().UseGlobalModuleIndex);
-      if (hasASTConsumer()) {
-        ModuleManager->setDeserializationListener(
-          getASTConsumer().GetASTDeserializationListener());
-        getASTContext().setASTMutationListener(
-          getASTConsumer().GetASTMutationListener());
-      }
-      OwningPtr<ExternalASTSource> Source;
-      Source.reset(ModuleManager);
-      getASTContext().setExternalSource(Source);
-      if (hasSema())
-        ModuleManager->InitializeSema(getSema());
-      if (hasASTConsumer())
-        ModuleManager->StartTranslationUnit(&getASTConsumer());
+      createModuleManager();
     }
 
     // Try to load the module file.
     unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
     switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
                                    ImportLoc, ARRFlags)) {
     case ASTReader::Success:
       break;

 
 void CompilerInstance::makeModuleVisible(Module *Mod,
                                          Module::NameVisibilityKind Visibility,
                                          SourceLocation ImportLoc,
                                          bool Complain){
   ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
 }
 
+GlobalModuleIndex *CompilerInstance::loadGlobalModuleIndex() {
+  if (!ModuleManager)
+    createModuleManager();
+  // Can't do anything if we don't have the module manager.
+  if (!ModuleManager)
+    return 0;
+  // Get an existing global index.  This load it if not already
+  // loaded.
+  ModuleManager->loadGlobalIndex();
+  GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
+  // If the global index doesn't exist, create it.
+  if (!GlobalIndex && shouldBuildGlobalModuleIndex() && hasFileManager() &&
+      hasPreprocessor()) {
+    llvm::sys::fs::create_directories(
+      getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
+    GlobalModuleIndex::writeIndex(
+      getFileManager(),
+      getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
+    ModuleManager->resetForReload();
+    ModuleManager->loadGlobalIndex();
+    GlobalIndex = ModuleManager->getGlobalIndex();
+  }
+  // For finding modules needing to be imported for fixit messages,
+  // we need to make the global index cover all modules, so we do that here.
+  if (!HaveFullGlobalModuleIndex && GlobalIndex) {
+    ModuleMap &MMap = getPreprocessor().getHeaderSearchInfo().getModuleMap();
+    bool recreateIndex = false;
+    for (ModuleMap::module_iterator I = MMap.module_begin(),
+        E = MMap.module_end(); I != E; ++I) {
+      Module *TheModule = I->second;
+      const FileEntry *Entry = TheModule->getASTFile();
+      if (!Entry) {
+        SourceLocation dummyLoc;
+        SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
+        for (Module *Mod = TheModule; Mod; Mod = Mod->Parent)
+          Path.push_back(std::make_pair(
+            getPreprocessor().getIdentifierInfo(Mod->Name), Mod->DefinitionLoc));
+          std::reverse(Path.begin(), Path.end());
+        // Load a module as hidden.  This also adds it to the global index.
+        ModuleLoadResult Result = loadModule(TheModule->DefinitionLoc, Path,
+          Module::Hidden, false);
+        recreateIndex = true;
+      }
+    }
+    if (recreateIndex) {
+      GlobalModuleIndex::writeIndex(
+        getFileManager(),
+        getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
+      ModuleManager->resetForReload();
+      ModuleManager->loadGlobalIndex();
+      GlobalIndex = ModuleManager->getGlobalIndex();
+    }
+    HaveFullGlobalModuleIndex = true;
+  }
+  return GlobalIndex;
+}

lib/Frontend/CompilerInvocation.cpp

#include "clang/Frontend/LangStandards.def"
   Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
   Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
 
   Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
   Opts.Blocks = Args.hasArg(OPT_fblocks);
   Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
   Opts.Modules = Args.hasArg(OPT_fmodules);
   Opts.ModulesDeclUse = Args.hasArg(OPT_fmodules_decluse);
+  Opts.ModulesSearchAll = Opts.Modules &&
+   (!Args.hasArg(OPT_fno_modules_search_all) ||
+     Args.hasArg(OPT_fmodules_search_all));
   Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
   Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
   Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
   Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
   Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
   Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
   Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
   Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
   Opts.SizedDeallocation |= Args.hasArg(OPT_fsized_deallocation);
   Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
   Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
   Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
   Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
   Opts.InstantiationDepth =
       getLastArgIntValue(Args, OPT_ftemplate_depth, 256, Diags);
   Opts.ArrowDepth =
       getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
   Opts.ConstexprCallDepth =
       getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
   Opts.ConstexprStepLimit =
       getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
   Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
   Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
   Opts.NumLargeByValueCopy =
       getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
   Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
   Opts.ObjCConstantStringClass =
     Args.getLastArgValue(OPT_fconstant_string_class);

lib/Lex/HeaderSearch.cpp

for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
     Module = ModMap.findModule(ModuleName);
     if (Module)
       break;
   }
 
   return Module;
 }
 
+Module *HeaderSearch::lookupModuleFromFile(StringRef ModuleFileName) {
+  return lookupModule(llvm::sys::path::stem(ModuleFileName), false);
+}
+
 //===----------------------------------------------------------------------===//
 // File lookup within a DirectoryLookup scope
 //===----------------------------------------------------------------------===//
 
 /// getName - Return the directory or filename corresponding to this lookup
 /// object.
 const char *DirectoryLookup::getName() const {
   if (isNormalDir())
if (IncludingHFI.IndexHeaderMapHeader) {
       std::pair<unsigned, unsigned> &CacheLookup 
         = LookupFileCache.GetOrCreateValue(Filename).getValue();
       CacheLookup.second
         = LookupFileCache.GetOrCreateValue(ScratchFilename).getValue().second;
       return Result;
     }
   }
 
+  // If no includers (as in case of module build), and not an angled
+  // include, do a final check in the current directory
+  if (Includers.empty() && !isAngled && !NoCurDirSearch) {
+    const FileEntry *Result = FileMgr.getFile(Filename, /*openFile=*/true);
+    if (Result) {
+      CacheLookup.second
+        = LookupFileCache.GetOrCreateValue(Filename).getValue().second;
+      return Result;
+    }
+  }
+
   // Otherwise, didn't find it. Remember we didn't find this.
   CacheLookup.second = SearchDirs.size();
   return 0;
 }
 
 /// LookupSubframeworkHeader - Look up a subframework for the specified
 /// \#include file.  For example, if \#include'ing <HIToolbox/HIToolbox.h> from
 /// within ".../Carbon.framework/Headers/Carbon.h", check to see if HIToolbox

lib/Parse/ParseDecl.cpp

case tok::identifier: {
         break;
 
       // [AltiVec] 2.2: [If the 'vector' specifier is used] The syntax does not
       //                allow the use of a typedef name as a type specifier.
       if (DS.isTypeAltiVecVector())
         goto DoneWithDeclSpec;
 
       ParsedType TypeRep =
-        Actions.getTypeName(*Tok.getIdentifierInfo(),
+        Actions.getTypeNameWithModuleCheck(*Tok.getIdentifierInfo(),
                             Tok.getLocation(), getCurScope());
 
       // If this is not a typedef name, don't parse it as part of the declspec,
       // it must be an implicit int or an error.
       if (!TypeRep) {
         ParsedAttributesWithRange Attrs(AttrFactory);
         if (ParseImplicitInt(DS, 0, TemplateInfo, AS, DSContext, Attrs)) {
           if (!Attrs.empty()) {

lib/Sema/SemaDecl.cpp

 #include "clang/AST/CharUnits.h"
 #include "clang/AST/CommentDiagnostic.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/StmtCXX.h"
+#include "clang/Basic/Module.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/HeaderSearch.h" // FIXME: Sema shouldn't depend on Lex
 #include "clang/Lex/ModuleLoader.h" // FIXME: Sema shouldn't depend on Lex
 #include "clang/Lex/Preprocessor.h" // FIXME: Sema shouldn't depend on Lex
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/CXXFieldCollector.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.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/Template.h"
+#include "clang/Serialization/GlobalModuleIndex.h"
+#include "clang/Serialization/Module.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
 #include <algorithm>
 #include <cstring>
 #include <functional>
 using namespace clang;
 using namespace sema;
 
ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
   if (T.isNull()) {
     // If it's not plausibly a type, suppress diagnostics.
     Result.suppressDiagnostics();
     return ParsedType();
   }
   return ParsedType::make(T);
 }
 
+// Calls getTypeName, and if not found, will search for a module with the
+// type, implicitly importing it and displaying a fixit message.
+// FIXME: Apparently, the global index only finds top-level modules, so
+// perhaps this isn't the right implementation, but it's a starting point,
+// and given the fixit message output, the user can probably figure out the
+// right import statement.
+// FIXME: Can we figure out the submodule from the type and refine the
+// visibility to just the submodule?
+// FIXME: Can we figure out where to put the fixit import/include?
+ParsedType Sema::getTypeNameWithModuleCheck(const IdentifierInfo &II,
+                        SourceLocation NameLoc,
+                        Scope *S, CXXScopeSpec *SS,
+                        bool isClassName,
+                        bool HasTrailingDot,
+                        ParsedType ObjectType,
+                        bool IsCtorOrDtorName,
+                        bool WantNontrivialTypeSourceInfo,
+                        IdentifierInfo **CorrectedII) {
+  // Do main look up, before checking non-imported modules.
+  ParsedType TypeRep = getTypeName(II, NameLoc, S, SS, isClassName,
+    HasTrailingDot, ObjectType, IsCtorOrDtorName,
+    WantNontrivialTypeSourceInfo, CorrectedII);
+
+  // If found exit now with the type.  Also exit if modules not enabled.
+  if (TypeRep || !getLangOpts().Modules || !getLangOpts().ModulesSearchAll)
+    return TypeRep;
+
+  // Otherwise try to find the type in modules via the global module index.
+  ModuleLoader &Loader = PP.getModuleLoader();
+  GlobalModuleIndex *GlobalIndex = Loader.loadGlobalModuleIndex();
+
+  if (!GlobalIndex)
+    return TypeRep;
+
+  GlobalModuleIndex::HitSet FoundModules;
+
+  // Find the modules that reference the identifier.
+  if (GlobalIndex->lookupIdentifier(II.getName(), FoundModules)) {
+    // Walk the found modules that reference the identifier.
+    for (GlobalModuleIndex::HitSet::iterator I = FoundModules.begin(),
+        E = FoundModules.end(); I != E; ++I) {
+      ModuleFile *TheModuleFile = *I;
+      // Find the module from the file name.
+      Module *TheModule = PP.getHeaderSearchInfo().lookupModuleFromFile(
+        TheModuleFile->FileName);
+      assert(TheModule && "Should be able to find the module.");
+      // Make the module visible so we can repeat the type lookup.
+      Loader.makeModuleVisible(TheModule, Module::AllVisible, NameLoc, false);
+      // Try the type lookup again.
+      TypeRep = getTypeName(II, NameLoc, S, SS, isClassName,
+        HasTrailingDot, ObjectType, IsCtorOrDtorName,
+        WantNontrivialTypeSourceInfo, CorrectedII);
+      // If we found the type, display a fixit warning and exit.
+      if (TypeRep) {
+        // FIXME: Can we figure out the submodule from the type and refine
+        // the visibility to just the submodule?
+        std::string fixit = "#import ";
+        fixit += TheModule->Name;
+        // FIXME: Figure out how to find the right insertion point,
+        // For now we just use the type location.
+        Diag(NameLoc, diag::warn_need_module_import)
+          << II.getName() << TheModule->getFullModuleName() <<
+          FixItHint::CreateInsertion(NameLoc, fixit);
+        break;
+      }
+      // Otherwise hide the module.
+      Loader.makeModuleVisible(TheModule, Module::Hidden, NameLoc, false);
+    }
+  }
+
+  return TypeRep;
+}
+
 /// isTagName() - This method is called *for error recovery purposes only*
 /// to determine if the specified name is a valid tag name ("struct foo").  If
 /// so, this returns the TST for the tag corresponding to it (TST_enum,
 /// TST_union, TST_struct, TST_interface, TST_class).  This is used to diagnose
 /// cases in C where the user forgot to specify the tag.
 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
   // Do a tag name lookup in this scope.
   LookupResult R(*this, &II, SourceLocation(), LookupTagName);
NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
 
   AddKnownFunctionAttributes(FD);
 
   return FD;
 }
 
 /// \brief Adds any function attributes that we know a priori based on
 /// the declaration of this function.
 ///
 /// These attributes can apply both to implicitly-declared builtins
 /// (like __builtin___printf_chk) or to library-declared functions
 /// like NSLog or printf.
 ///
 /// We need to check for duplicate attributes both here and where user-written
 /// attributes are applied to declarations.
 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
   if (FD->isInvalidDecl())

lib/Serialization/GlobalModuleIndex.cpp

 //===--- GlobalModuleIndex.cpp - Global Module Index ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the GlobalModuleIndex class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ASTReaderInternals.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/OnDiskHashTable.h"
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Serialization/GlobalModuleIndex.h"
 #include "clang/Serialization/Module.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/LockFileManager.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include <cstdio>
 using namespace clang;
 using namespace serialization;
 
 //----------------------------------------------------------------------------//
 // Shared constants
 //----------------------------------------------------------------------------//
 namespace {
void GlobalModuleIndex::printStats() {
   if (NumIdentifierLookups) {
     fprintf(stderr, "  %u / %u identifier lookups succeeded (%f%%)\n",
             NumIdentifierLookupHits, NumIdentifierLookups,
             (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
   }
   std::fprintf(stderr, "\n");
 }
 
+void GlobalModuleIndex::dump() {
+  std::fprintf(stderr, "*** Global Module Index Dump:\n");
+  std::fprintf(stderr, "Module files:\n");
+  for (llvm::SmallVector<ModuleInfo, 16>::iterator I = Modules.begin(),
+      E = Modules.end(); I != E; ++I) {
+    ModuleInfo *MI = (ModuleInfo*)I;
+    std::fprintf(stderr, "** %s\n", MI->FileName.c_str());
+    if (MI->File)
+      MI->File->dump();
+    else
+      std::fprintf(stderr, "\n");
+  }
+  std::fprintf(stderr, "\n");
+}
+
 //----------------------------------------------------------------------------//
 // Global module index writer.
 //----------------------------------------------------------------------------//
 
 namespace {
   /// \brief Provides information about a specific module file.
   struct ModuleFileInfo {
     /// \brief The numberic ID for this module file.

test/Modules/Inputs/undefined-type-fixit/module.map

+module public1 {
+  header "public1.h"
+}
+module public2 {
+  header "public2.h"
+  module public2sub {
+    header "public2sub.h"
+  }
+}

test/Modules/Inputs/undefined-type-fixit/public1.h

+#ifndef PUBLIC1_H
+#define PUBLIC1_H
+
+struct use_this1 { int field; };
+
+#endif

test/Modules/Inputs/undefined-type-fixit/public2.h

+#ifndef PUBLIC2_H
+#define PUBLIC2_H
+
+struct use_this2 { int field; };
+
+#endif

test/Modules/Inputs/undefined-type-fixit/public2sub.h

+#ifndef PUBLIC2SUB_H
+#define PUBLIC2SUB_H
+
+struct use_this2sub { int field; };
+
+#endif

test/Modules/auto-module-import.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify -DERRORS
-// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -F %S/Inputs %s -verify
+// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fno-modules-search-all -F %S/Inputs %s -verify -DERRORS
+// RUN: %clang_cc1 -Wauto-import -fmodules-cache-path=%t -fmodules -fno-modules-search-all -F %S/Inputs %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'}}
 
 #ifdef MODULE_H_MACRO
 #  error MODULE_H_MACRO should have been hidden

test/Modules/cxx-inline-namespace.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11
+// RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-search-all -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11
 
 @import cxx_inline_namespace;
 
 T x; // expected-error {{unknown type name 'T'}}

test/Modules/cxx-linkage-cache.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x objective-c++ -fmodules -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11
+// RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-search-all -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11
 
 @import cxx_linkage_cache;
 
 T x; // expected-error {{unknown type name 'T'}}
 D::U<int> u;
 bool b = f(u);

test/Modules/decldef.m

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_EARLY
-// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify
+// RUN: %clang_cc1 -fmodules -fno-modules-search-all -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_EARLY
+// RUN: %clang_cc1 -fmodules -fno-modules-search-all -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify
 
 // expected-note@Inputs/def.h:5 {{previous}}
 
 @class Def;
 Def *def;
 
 @import decldef;
 #ifdef USE_EARLY

test/Modules/decldef.mm

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_EARLY
-// RUN: %clang_cc1 -fmodules -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify
+// RUN: %clang_cc1 -fmodules -fno-modules-search-all -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify -DUSE_EARLY
+// RUN: %clang_cc1 -fmodules -fno-modules-search-all -fobjc-arc -I %S/Inputs -fmodules-cache-path=%t %s -verify
 
 // expected-note@Inputs/def.h:5 {{previous}}
 
 @class Def;
 Def *def;
 class Def2; // expected-note {{forward decl}}
 Def2 *def2;
 namespace Def3NS { class Def3; } // expected-note {{forward decl}}

test/Modules/module-private.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_left -emit-module %S/Inputs/module.map
-// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_right -emit-module %S/Inputs/module.map
-// RUN: %clang_cc1 -fmodules -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s -verify
+// RUN: %clang_cc1 -fmodules -fno-modules-search-all -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_left -emit-module %S/Inputs/module.map
+// RUN: %clang_cc1 -fmodules -fno-modules-search-all -x objective-c++ -fmodules-cache-path=%t -fmodule-name=module_private_right -emit-module %S/Inputs/module.map
+// RUN: %clang_cc1 -fmodules -fno-modules-search-all -x objective-c++ -fmodules-cache-path=%t -I %S/Inputs %s -verify
 // FIXME: When we have a syntax for modules in C++, use that.
 
 @import module_private_left;
 @import module_private_right;
 
 void test() {
   int &ir = f0(1.0); // okay: f0() from 'right' is not visible
 }

test/Modules/submodules.cpp

 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -I %S/Inputs/submodules %s -verify
+// RUN: %clang_cc1 -x objective-c++ -fmodules-cache-path=%t -fmodules -fno-modules-search-all -I %S/Inputs/submodules %s -verify
 // FIXME: When we have a syntax for modules in C++, use that.
 
 @import std.vector;
 
 vector<int> vi;
 
 // Note: remove_reference is not visible yet.
 remove_reference<int&>::type *int_ptr = 0; // expected-error{{declaration of 'remove_reference' must be imported from module 'std.type_traits' before it is required}}

test/Modules/undefined-type-fixit1.cpp

+// RUN: rm -rf %t
+// RUN: %clang_cc1 -fmodules-cache-path=%t -fmodules -I %S/Inputs/undefined-type-fixit %s -verify
+
+//#include "public1.h"
+#include "public2.h"
+#include "public2sub.h"
+
+use_this1 client_variable1; // expected-warning {{Use of identifier 'use_this1' requires import/inclusion of the module 'public1'}}
+use_this2 client_variable2;
+use_this2sub client_variable2sub;

unittests/Basic/SourceManagerTest.cpp

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
                                       bool IsInclusionDirective) {
     return ModuleLoadResult();
   }
 
   virtual void makeModuleVisible(Module *Mod,
                                  Module::NameVisibilityKind Visibility,
                                  SourceLocation ImportLoc,
                                  bool Complain) { }
+
+  virtual GlobalModuleIndex *loadGlobalModuleIndex() { return 0; }
 };
 
 TEST_F(SourceManagerTest, isBeforeInTranslationUnit) {
   const char *source =
     "#define M(x) [x]\n"
     "M(foo)";
   MemoryBuffer *buf = MemoryBuffer::getMemBuffer(source);
   FileID mainFileID = SourceMgr.createMainFileIDForMemBuffer(buf);

unittests/Lex/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(LexTests
   LexerTest.cpp
   PPCallbacksTest.cpp
   PPConditionalDirectiveRecordTest.cpp
   )
 
 target_link_libraries(LexTests
   clangAST
   clangBasic
   clangLex
   clangParse
   clangSema
+  clangSerialization
   )

unittests/Lex/LexerTest.cpp

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
                                       bool IsInclusionDirective) {
     return ModuleLoadResult();
   }
 
   virtual void makeModuleVisible(Module *Mod,
                                  Module::NameVisibilityKind Visibility,
                                  SourceLocation ImportLoc,
                                  bool Complain) { }
+
+  virtual GlobalModuleIndex *loadGlobalModuleIndex() { return 0; }
 };
 
 // The test fixture.
 class LexerTest : public ::testing::Test {
 protected:
   LexerTest()
     : FileMgr(FileMgrOpts),
       DiagID(new DiagnosticIDs()),

unittests/Lex/Makefile

 ##===- unittests/Lex/Makefile ------------------------------*- Makefile -*-===##
 #
 #                     The LLVM Compiler Infrastructure
 #
 # This file is distributed under the University of Illinois Open Source
 # License. See LICENSE.TXT for details.
 #
 ##===----------------------------------------------------------------------===##
 
 CLANG_LEVEL = ../..
 TESTNAME = Lex
-LINK_COMPONENTS := mcparser support mc
+LINK_COMPONENTS := mcparser support mc bitreader
 USEDLIBS = clangParse.a clangSema.a clangAnalysis.a clangEdit.a \
-  clangAST.a clangLex.a clangBasic.a 
+  clangSerialization.a clangAST.a clangLex.a clangBasic.a 
 
 include $(CLANG_LEVEL)/unittests/Makefile

unittests/Lex/PPCallbacksTest.cpp

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
                                       bool IsInclusionDirective) {
     return ModuleLoadResult();
   }
 
   virtual void makeModuleVisible(Module *Mod,
                                  Module::NameVisibilityKind Visibility,
                                  SourceLocation ImportLoc,
                                  bool Complain) { }
+
+  virtual GlobalModuleIndex *loadGlobalModuleIndex() { return 0; }
 };
 
 // Stub to collect data from InclusionDirective callbacks.
 class InclusionDirectiveCallbacks : public PPCallbacks {
 public:
   void InclusionDirective(SourceLocation HashLoc, 
     const Token &IncludeTok, 
     StringRef FileName, 

unittests/Lex/PPConditionalDirectiveRecordTest.cpp

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
                                       bool IsInclusionDirective) {
     return ModuleLoadResult();
   }
 
   virtual void makeModuleVisible(Module *Mod,
                                  Module::NameVisibilityKind Visibility,
                                  SourceLocation ImportLoc,
                                  bool Complain) { }
+
+  virtual GlobalModuleIndex *loadGlobalModuleIndex() { return 0; }
 };
 
 TEST_F(PPConditionalDirectiveRecordTest, PPRecAPI) {
   const char *source =
       "0 1\n"
       "#if 1\n"
       "2\n"
       "#ifndef BB\n"