[flang] Support multiple CookedSource instances

[klausler]

Summary

These are owned by an instance of a new class AllCookedSources.

This removes the need for a Scope to own a string containing
a module's cooked source stream, and will enable errors to be
emitted when parsing module files in the future.

[PeteSteinfeld]

Builds, tests, and looks good.

[PeteSteinfeld]

Oops, I approved too soon. I'm still looking at this.

[PeteSteinfeld]

I get failures in Semantics/getsymbols02.f90. I can't figure out how to cancel my previous approval, though.

[klausler]

Update test results.

flang/include/flang/Lower/Bridge.h

 namespace Fortran {
 namespace common {
 class IntrinsicTypeDefaultKinds;
 } // namespace common
 namespace evaluate {
 class IntrinsicProcTable;
 } // namespace evaluate
 namespace parser {
-class CookedSource;
+class AllCookedSources;
 struct Program;
 } // namespace parser
 namespace semantics {
 class SemanticsContext;
 } // namespace semantics
 
 namespace lower {
 
 //===----------------------------------------------------------------------===//
 // Lowering bridge
 //===----------------------------------------------------------------------===//
 
 /// The lowering bridge converts the front-end parse trees and semantics
 /// checking residual to MLIR (FIR dialect) code.
 class LoweringBridge {
 public:
   /// Create a lowering bridge instance.
   static LoweringBridge
   create(const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
          const Fortran::evaluate::IntrinsicProcTable &intrinsics,
-         const Fortran::parser::CookedSource &cooked) {
-    return LoweringBridge{defaultKinds, intrinsics, cooked};
+         const Fortran::parser::AllCookedSources &allCooked) {
+    return LoweringBridge{defaultKinds, intrinsics, allCooked};
   }
 
   //===--------------------------------------------------------------------===//
   // Getters
   //===--------------------------------------------------------------------===//
 
   mlir::MLIRContext &getMLIRContext() { return *context.get(); }
   mlir::ModuleOp &getModule() { return *module.get(); }
   const Fortran::common::IntrinsicTypeDefaultKinds &getDefaultKinds() const {
     return defaultKinds;
   }
   const Fortran::evaluate::IntrinsicProcTable &getIntrinsicTable() const {
     return intrinsics;
   }
-  const Fortran::parser::CookedSource *getCookedSource() const {
+  const Fortran::parser::AllCookedSources *getCookedSource() const {
     return cooked;
   }
 
   /// Get the kind map.
   const fir::KindMapping &getKindMap() const { return kindMap; }
 
   /// Create a folding context. Careful: this is very expensive.
   Fortran::evaluate::FoldingContext createFoldingContext() const;
public:
   /// Cross the bridge from the Fortran parse-tree, etc. to MLIR dialects
   void lower(const Fortran::parser::Program &program, fir::NameUniquer &uniquer,
              const Fortran::semantics::SemanticsContext &semanticsContext);
 
 private:
   explicit LoweringBridge(
       const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
       const Fortran::evaluate::IntrinsicProcTable &intrinsics,
-      const Fortran::parser::CookedSource &cooked);
+      const Fortran::parser::AllCookedSources &);
   LoweringBridge() = delete;
   LoweringBridge(const LoweringBridge &) = delete;
 
   const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds;
   const Fortran::evaluate::IntrinsicProcTable &intrinsics;
-  const Fortran::parser::CookedSource *cooked;
+  const Fortran::parser::AllCookedSources *cooked;
   std::unique_ptr<mlir::MLIRContext> context;
   std::unique_ptr<mlir::ModuleOp> module;
   fir::KindMapping kindMap;
 };
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_BRIDGE_H

flang/include/flang/Lower/ConvertType.h

 class Expr;
 template <common::TypeCategory>
 struct SomeKind;
 struct SomeType;
 template <common::TypeCategory, int>
 class Type;
 } // namespace evaluate
 
-namespace parser {
-class CharBlock;
-class CookedSource;
-} // namespace parser
-
 namespace semantics {
 class Symbol;
 } // namespace semantics
 
 namespace lower {
 namespace pft {
 struct Variable;
 }

flang/include/flang/Parser/instrumented-parser.h

 public:
   ParsingLog() {}
 
   void clear();
 
   bool Fails(const char *at, const MessageFixedText &tag, ParseState &);
   void Note(const char *at, const MessageFixedText &tag, bool pass,
       const ParseState &);
-  void Dump(llvm::raw_ostream &, const CookedSource &) const;
+  void Dump(llvm::raw_ostream &, const AllCookedSources &) const;
 
 private:
   struct LogForPosition {
     struct Entry {
       Entry() {}
       bool pass{true};
       int count{0};
       bool deferred{false};

flang/include/flang/Parser/message.h

public:
   Message &Attach(std::unique_ptr<Message> &&);
   template <typename... A> Message &Attach(A &&...args) {
     return Attach(new Message{std::forward<A>(args)...}); // reference-counted
   }
 
   bool SortBefore(const Message &that) const;
   bool IsFatal() const;
   std::string ToString() const;
-  std::optional<ProvenanceRange> GetProvenanceRange(const CookedSource &) const;
-  void Emit(llvm::raw_ostream &, const CookedSource &,
+  std::optional<ProvenanceRange> GetProvenanceRange(
+      const AllCookedSources &) const;
+  void Emit(llvm::raw_ostream &, const AllCookedSources &,
       bool echoSourceLine = true) const;
 
-  // If this Message or any of its attachments locates itself via a CharBlock
-  // within a particular CookedSource, replace its location with the
-  // corresponding ProvenanceRange.
-  void ResolveProvenances(const CookedSource &);
+  // If this Message or any of its attachments locates itself via a CharBlock,
+  // replace its location with the corresponding ProvenanceRange.
+  void ResolveProvenances(const AllCookedSources &);
 
   bool IsMergeable() const {
     return std::holds_alternative<MessageExpectedText>(text_);
   }
   bool Merge(const Message &);
 
 private:
   bool AtSameLocation(const Message &) const;
public:
   void Restore(Messages &&that) {
     that.Annex(std::move(*this));
     *this = std::move(that);
   }
 
   bool Merge(const Message &);
   void Merge(Messages &&);
   void Copy(const Messages &);
-  void ResolveProvenances(const CookedSource &);
-  void Emit(llvm::raw_ostream &, const CookedSource &cooked,
+  void ResolveProvenances(const AllCookedSources &);
+  void Emit(llvm::raw_ostream &, const AllCookedSources &,
       bool echoSourceLines = true) const;
   void AttachTo(Message &);
   bool AnyFatalError() const;
 
 private:
   void ResetLastPointer() { last_ = messages_.before_begin(); }
 
   std::forward_list<Message> messages_;

flang/include/flang/Parser/parsing.h

struct Options {
   std::vector<Predefinition> predefinitions;
   bool instrumentedParse{false};
   bool isModuleFile{false};
   bool needProvenanceRangeToCharBlockMappings{false};
 };
 
 class Parsing {
 public:
-  explicit Parsing(AllSources &);
+  explicit Parsing(AllCookedSources &);
   ~Parsing();
 
   bool consumedWholeFile() const { return consumedWholeFile_; }
   const char *finalRestingPlace() const { return finalRestingPlace_; }
-  CookedSource &cooked() { return cooked_; }
+  AllCookedSources &allCooked() { return allCooked_; }
   Messages &messages() { return messages_; }
   std::optional<Program> &parseTree() { return parseTree_; }
 
+  const CookedSource &cooked() const { return DEREF(currentCooked_); }
+
   const SourceFile *Prescan(const std::string &path, Options);
   void DumpCookedChars(llvm::raw_ostream &) const;
   void DumpProvenance(llvm::raw_ostream &) const;
   void DumpParsingLog(llvm::raw_ostream &) const;
   void Parse(llvm::raw_ostream &debugOutput);
   void ClearLog();
 
   void EmitMessage(llvm::raw_ostream &o, const char *at,
       const std::string &message, bool echoSourceLine = false) const {
-    cooked_.allSources().EmitMessage(
-        o, cooked_.GetProvenanceRange(CharBlock(at)), message, echoSourceLine);
+    allCooked_.allSources().EmitMessage(o,
+        allCooked_.GetProvenanceRange(CharBlock(at)), message, echoSourceLine);
   }
 
 private:
   Options options_;
-  CookedSource cooked_;
+  AllCookedSources &allCooked_;
+  CookedSource *currentCooked_{nullptr};
   Messages messages_;
   bool consumedWholeFile_{false};
   const char *finalRestingPlace_{nullptr};
   std::optional<Program> parseTree_;
   ParsingLog log_;
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PARSING_H_

flang/include/flang/Parser/provenance.h

 #include "char-block.h"
 #include "char-buffer.h"
 #include "characters.h"
 #include "source.h"
 #include "flang/Common/idioms.h"
 #include "flang/Common/interval.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstddef>
+#include <list>
 #include <map>
 #include <memory>
 #include <optional>
 #include <string>
 #include <utility>
 #include <variant>
 #include <vector>
 
private:
   std::vector<Origin> origin_;
   ProvenanceRange range_;
   std::map<char, Provenance> compilerInsertionProvenance_;
   std::vector<std::unique_ptr<SourceFile>> ownedSourceFiles_;
   std::vector<std::string> searchPath_;
   Encoding encoding_{Encoding::UTF_8};
 };
 
+// Represents the result of preprocessing and prescanning a single source
+// file (and all its inclusions) or module file.  Parsers operate within
+// single instances of CookedSource.
 class CookedSource {
 public:
-  explicit CookedSource(AllSources &);
-  ~CookedSource();
-
-  AllSources &allSources() { return allSources_; }
-  const AllSources &allSources() const { return allSources_; }
   const std::string &data() const { return data_; }
 
-  bool IsValid(const char *p) const {
+  bool Contains(const char *p) const {
     return p >= &data_.front() && p <= &data_.back() + 1;
   }
-  bool IsValid(CharBlock range) const {
-    return !range.empty() && IsValid(range.begin()) && IsValid(range.end() - 1);
+  bool Contains(CharBlock range) const {
+    return !range.empty() && Contains(range.begin()) &&
+        Contains(range.end() - 1);
   }
-  bool IsValid(ProvenanceRange r) const { return allSources_.IsValid(r); }
 
   std::optional<ProvenanceRange> GetProvenanceRange(CharBlock) const;
-  std::optional<CharBlock> GetCharBlockFromLineAndColumns(
-      int line, int startColumn, int endColumn) const;
-  std::optional<std::pair<SourcePosition, SourcePosition>>
-      GetSourcePositionRange(CharBlock) const;
   std::optional<CharBlock> GetCharBlock(ProvenanceRange) const;
 
   // The result of a Put() is the offset that the new data
   // will have in the eventually marshaled contiguous buffer.
   std::size_t Put(const char *data, std::size_t bytes) {
     return buffer_.Put(data, bytes);
   }
   std::size_t Put(const std::string &s) { return buffer_.Put(s); }
   std::size_t Put(char ch) { return buffer_.Put(&ch, 1); }
   std::size_t Put(char ch, Provenance p) {
     provenanceMap_.Put(ProvenanceRange{p, 1});
     return buffer_.Put(&ch, 1);
   }
 
   void PutProvenance(Provenance p) { provenanceMap_.Put(ProvenanceRange{p}); }
   void PutProvenance(ProvenanceRange pr) { provenanceMap_.Put(pr); }
   void PutProvenanceMappings(const OffsetToProvenanceMappings &pm) {
     provenanceMap_.Put(pm);
   }
 
   std::size_t BufferedBytes() const;
-  void Marshal(); // marshals text into one contiguous block
-  void CompileProvenanceRangeToOffsetMappings();
+  void Marshal(AllSources &); // marshals text into one contiguous block
+  void CompileProvenanceRangeToOffsetMappings(AllSources &);
   std::string AcquireData() { return std::move(data_); }
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
-  AllSources &allSources_;
   CharBuffer buffer_; // before Marshal()
   std::string data_; // all of it, prescanned and preprocessed
   OffsetToProvenanceMappings provenanceMap_;
   ProvenanceRangeToOffsetMappings invertedMap_;
 };
+
+class AllCookedSources {
+public:
+  explicit AllCookedSources(AllSources &);
+  ~AllCookedSources();
+
+  AllSources &allSources() { return allSources_; }
+  const AllSources &allSources() const { return allSources_; }
+
+  CookedSource &NewCookedSource();
+
+  template <typename A> // const char * or CharBlock
+  const CookedSource *Find(A x) const {
+    for (const auto &c : cooked_) {
+      if (c.Contains(x)) {
+        return &c;
+      }
+    }
+    return nullptr;
+  }
+
+  bool IsValid(ProvenanceRange r) const { return allSources_.IsValid(r); }
+
+  std::optional<ProvenanceRange> GetProvenanceRange(CharBlock) const;
+  std::optional<CharBlock> GetCharBlockFromLineAndColumns(
+      int line, int startColumn, int endColumn) const;
+  std::optional<std::pair<SourcePosition, SourcePosition>>
+      GetSourcePositionRange(CharBlock) const;
+  std::optional<CharBlock> GetCharBlock(ProvenanceRange) const;
+  void Dump(llvm::raw_ostream &) const;
+
+private:
+  AllSources &allSources_;
+  std::list<CookedSource> cooked_; // owns all CookedSource instances
+};
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PROVENANCE_H_

flang/include/flang/Parser/user-state.h

 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <optional>
 #include <set>
 #include <unordered_map>
 
 namespace Fortran::parser {
 
-class CookedSource;
+class AllCookedSources;
 class ParsingLog;
 class ParseState;
 
 class Success {}; // for when one must return something that's present
 
 class UserState {
 public:
-  UserState(const CookedSource &cooked, common::LanguageFeatureControl features)
-      : cooked_{cooked}, features_{features} {}
+  UserState(const AllCookedSources &allCooked,
+      common::LanguageFeatureControl features)
+      : allCooked_{allCooked}, features_{features} {}
 
-  const CookedSource &cooked() const { return cooked_; }
+  const AllCookedSources &allCooked() const { return allCooked_; }
   const common::LanguageFeatureControl &features() const { return features_; }
 
   llvm::raw_ostream *debugOutput() const { return debugOutput_; }
   UserState &set_debugOutput(llvm::raw_ostream &out) {
     debugOutput_ = &out;
     return *this;
   }
 
public:
   void NoteOldStructureComponent(const CharBlock &name) {
     oldStructureComponents_.insert(name);
   }
   bool IsOldStructureComponent(const CharBlock &name) const {
     return oldStructureComponents_.find(name) != oldStructureComponents_.end();
   }
 
 private:
-  const CookedSource &cooked_;
+  const AllCookedSources &allCooked_;
 
   llvm::raw_ostream *debugOutput_{nullptr};
 
   ParsingLog *log_{nullptr};
   bool instrumentedParse_{false};
 
   std::unordered_map<Label, int> doLabels_;
   int nonlabelDoConstructNestingDepth_{0};

flang/include/flang/Semantics/scope.h

public:
   const DeclTypeSpec &MakeNumericType(TypeCategory, KindExpr &&kind);
   const DeclTypeSpec &MakeLogicalType(KindExpr &&kind);
   const DeclTypeSpec &MakeCharacterType(
       ParamValue &&length, KindExpr &&kind = KindExpr{0});
   DeclTypeSpec &MakeDerivedType(DeclTypeSpec::Category, DerivedTypeSpec &&);
   const DeclTypeSpec &MakeTypeStarType();
   const DeclTypeSpec &MakeClassStarType();
 
-  // For modules read from module files, this is the stream of characters
-  // that are referenced by SourceName objects.
-  void set_chars(parser::CookedSource &);
-
   std::size_t size() const { return size_; }
   void set_size(std::size_t size) { size_ = size; }
   std::size_t alignment() const { return alignment_; }
   void set_alignment(std::size_t alignment) { alignment_ = alignment; }
 
   ImportKind GetImportKind() const;
   // Names appearing in IMPORT statements in this scope
   std::set<SourceName> importNames() const { return importNames_; }
private:
   Symbol *const symbol_; // if not null, symbol_->scope() == this
   std::list<Scope> children_;
   mapType symbols_;
   mapType commonBlocks_;
   std::list<EquivalenceSet> equivalenceSets_;
   mapType crayPointers_;
   std::map<SourceName, common::Reference<Scope>> submodules_;
   std::list<DeclTypeSpec> declTypeSpecs_;
-  std::string chars_;
   std::optional<ImportKind> importKind_;
   std::set<SourceName> importNames_;
   DerivedTypeSpec *derivedTypeSpec_{nullptr}; // dTS->scope() == this
   bool hasSAVE_{false}; // scope has a bare SAVE statement
   // When additional data members are added to Scope, remember to
   // copy them, if appropriate, in InstantiateDerivedType().
 
   // Storage for all Symbols. Every Symbol is in allSymbols and every Symbol*

flang/include/flang/Semantics/semantics.h

 
 namespace Fortran::common {
 class IntrinsicTypeDefaultKinds;
 }
 
 namespace Fortran::parser {
 struct Name;
 struct Program;
-class CookedSource;
+class AllCookedSources;
 struct AssociateConstruct;
 struct BlockConstruct;
 struct CaseConstruct;
 struct DoConstruct;
 struct ChangeTeamConstruct;
 struct CriticalConstruct;
 struct ForallConstruct;
 struct IfConstruct;
using ConstructNode = std::variant<const parser::AssociateConstruct *,
     const parser::DoConstruct *, const parser::ForallConstruct *,
     const parser::IfConstruct *, const parser::SelectRankConstruct *,
     const parser::SelectTypeConstruct *, const parser::WhereConstruct *>;
 using ConstructStack = std::vector<ConstructNode>;
 
 class SemanticsContext {
 public:
   SemanticsContext(const common::IntrinsicTypeDefaultKinds &,
-      const common::LanguageFeatureControl &, parser::AllSources &);
+      const common::LanguageFeatureControl &, parser::AllCookedSources &);
   ~SemanticsContext();
 
   const common::IntrinsicTypeDefaultKinds &defaultKinds() const {
     return defaultKinds_;
   }
   const common::LanguageFeatureControl &languageFeatures() const {
     return languageFeatures_;
   };
public:
   const std::string &moduleFileSuffix() const { return moduleFileSuffix_; }
   bool warnOnNonstandardUsage() const { return warnOnNonstandardUsage_; }
   bool warningsAreErrors() const { return warningsAreErrors_; }
   bool debugModuleWriter() const { return debugModuleWriter_; }
   const evaluate::IntrinsicProcTable &intrinsics() const { return intrinsics_; }
   Scope &globalScope() { return globalScope_; }
   parser::Messages &messages() { return messages_; }
   evaluate::FoldingContext &foldingContext() { return foldingContext_; }
-  parser::AllSources &allSources() { return allSources_; }
+  parser::AllCookedSources &allCookedSources() { return allCookedSources_; }
 
   SemanticsContext &set_location(
       const std::optional<parser::CharBlock> &location) {
     location_ = location;
     return *this;
   }
   SemanticsContext &set_searchDirectories(const std::vector<std::string> &x) {
     searchDirectories_ = x;

 
 private:
   void CheckIndexVarRedefine(
       const parser::CharBlock &, const Symbol &, parser::MessageFixedText &&);
   void CheckError(const Symbol &);
 
   const common::IntrinsicTypeDefaultKinds &defaultKinds_;
   const common::LanguageFeatureControl languageFeatures_;
-  parser::AllSources &allSources_;
+  parser::AllCookedSources &allCookedSources_;
   std::optional<parser::CharBlock> location_;
   std::vector<std::string> searchDirectories_;
   std::string moduleDirectory_{"."s};
   std::string moduleFileSuffix_{".mod"};
   bool warnOnNonstandardUsage_{false};
   bool warningsAreErrors_{false};
   bool debugModuleWriter_{false};
   const evaluate::IntrinsicProcTable intrinsics_;
   Scope globalScope_;
   parser::Messages messages_;
   evaluate::FoldingContext foldingContext_;
   ConstructStack constructStack_;
   struct IndexVarInfo {
     parser::CharBlock location;
     IndexVarKind kind;
   };
   std::map<SymbolRef, const IndexVarInfo> activeIndexVars_;
   std::set<SymbolRef> errorSymbols_;
   std::vector<std::string> tempNames_;
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
-      parser::CookedSource &cooked, bool debugModuleWriter = false)
-      : context_{context}, program_{program}, cooked_{cooked} {
+      const parser::CookedSource &cooked, bool debugModuleWriter = false)
+      : context_{context}, program_{program} {
     context.set_debugModuleWriter(debugModuleWriter);
     context.globalScope().AddSourceRange(parser::CharBlock{cooked.data()});
   }
 
   SemanticsContext &context() const { return context_; }
   bool Perform();
   const Scope &FindScope(const parser::CharBlock &where) const {
     return context_.FindScope(where);
   }
   bool AnyFatalError() const { return context_.AnyFatalError(); }
   void EmitMessages(llvm::raw_ostream &) const;
   void DumpSymbols(llvm::raw_ostream &);
   void DumpSymbolsSources(llvm::raw_ostream &) const;
 
 private:
   SemanticsContext &context_;
   parser::Program &program_;
-  const parser::CookedSource &cooked_;
 };
 
 // Base class for semantics checkers.
 struct BaseChecker {
   template <typename N> void Enter(const N &) {}
   template <typename N> void Leave(const N &) {}
 };
 } // namespace Fortran::semantics
 #endif

flang/lib/Parser/debug-parser.cpp

 namespace Fortran::parser {
 
 std::optional<Success> DebugParser::Parse(ParseState &state) const {
   if (auto ustate{state.userState()}) {
     if (auto out{ustate->debugOutput()}) {
       std::string note{str_, length_};
       Message message{state.GetLocation(), "parser debug: %s"_en_US, note};
       message.SetContext(state.context().get());
-      message.Emit(*out, ustate->cooked(), true);
+      message.Emit(*out, ustate->allCooked(), true);
     }
   }
-  return {Success{}};
+  return Success{};
 }
 } // namespace Fortran::parser

flang/lib/Parser/instrumented-parser.cpp

if (++entry.count == 1) {
     CHECK(entry.pass == pass);
     if (entry.deferred && !state.deferMessages()) {
       entry.deferred = false;
       entry.messages.Copy(state.messages());
     }
   }
 }
 
-void ParsingLog::Dump(llvm::raw_ostream &o, const CookedSource &cooked) const {
+void ParsingLog::Dump(
+    llvm::raw_ostream &o, const AllCookedSources &allCooked) const {
   for (const auto &posLog : perPos_) {
     const char *at{reinterpret_cast<const char *>(posLog.first)};
     for (const auto &tagLog : posLog.second.perTag) {
-      Message{at, tagLog.first}.Emit(o, cooked, true);
+      Message{at, tagLog.first}.Emit(o, allCooked, true);
       auto &entry{tagLog.second};
       o << "  " << (entry.pass ? "pass" : "fail") << " " << entry.count << '\n';
-      entry.messages.Emit(o, cooked);
+      entry.messages.Emit(o, allCooked);
     }
   }
 }
 } // namespace Fortran::parser

flang/lib/Parser/message.cpp

return std::visit(
             return t.text().NULTerminatedToString();
           },
           [](const MessageFormattedText &t) { return t.string(); },
           [](const MessageExpectedText &e) { return e.ToString(); },
       },
       text_);
 }
 
-void Message::ResolveProvenances(const CookedSource &cooked) {
+void Message::ResolveProvenances(const AllCookedSources &allCooked) {
   if (CharBlock * cb{std::get_if<CharBlock>(&location_)}) {
     if (std::optional<ProvenanceRange> resolved{
-            cooked.GetProvenanceRange(*cb)}) {
+            allCooked.GetProvenanceRange(*cb)}) {
       location_ = *resolved;
     }
   }
   if (Message * attachment{attachment_.get()}) {
-    attachment->ResolveProvenances(cooked);
+    attachment->ResolveProvenances(allCooked);
   }
 }
 
 std::optional<ProvenanceRange> Message::GetProvenanceRange(
-    const CookedSource &cooked) const {
+    const AllCookedSources &allCooked) const {
   return std::visit(
       common::visitors{
-          [&](CharBlock cb) { return cooked.GetProvenanceRange(cb); },
+          [&](CharBlock cb) { return allCooked.GetProvenanceRange(cb); },
           [](const ProvenanceRange &pr) { return std::make_optional(pr); },
       },
       location_);
 }
 
-void Message::Emit(llvm::raw_ostream &o, const CookedSource &cooked,
+void Message::Emit(llvm::raw_ostream &o, const AllCookedSources &allCooked,
     bool echoSourceLine) const {
-  std::optional<ProvenanceRange> provenanceRange{GetProvenanceRange(cooked)};
+  std::optional<ProvenanceRange> provenanceRange{GetProvenanceRange(allCooked)};
   std::string text;
   if (IsFatal()) {
     text += "error: ";
   }
   text += ToString();
-  const AllSources &sources{cooked.allSources()};
+  const AllSources &sources{allCooked.allSources()};
   sources.EmitMessage(o, provenanceRange, text, echoSourceLine);
   if (attachmentIsContext_) {
     for (const Message *context{attachment_.get()}; context;
          context = context->attachment_.get()) {
       std::optional<ProvenanceRange> contextProvenance{
-          context->GetProvenanceRange(cooked)};
+          context->GetProvenanceRange(allCooked)};
       text = "in the context: ";
       text += context->ToString();
       // TODO: don't echo the source lines of a context when it's the
       // same line (or maybe just never echo source for context)
       sources.EmitMessage(o, contextProvenance, text,
           echoSourceLine && contextProvenance != provenanceRange);
       provenanceRange = contextProvenance;
     }
   } else {
     for (const Message *attachment{attachment_.get()}; attachment;
          attachment = attachment->attachment_.get()) {
-      sources.EmitMessage(o, attachment->GetProvenanceRange(cooked),
+      sources.EmitMessage(o, attachment->GetProvenanceRange(allCooked),
           attachment->ToString(), echoSourceLine);
     }
   }
 }
 
 bool Message::Merge(const Message &that) {
   return AtSameLocation(that) &&
       (!that.attachment_.get() ||

 
 void Messages::Copy(const Messages &that) {
   for (const Message &m : that.messages_) {
     Message copy{m};
     Say(std::move(copy));
   }
 }
 
-void Messages::ResolveProvenances(const CookedSource &cooked) {
+void Messages::ResolveProvenances(const AllCookedSources &allCooked) {
   for (Message &m : messages_) {
-    m.ResolveProvenances(cooked);
+    m.ResolveProvenances(allCooked);
   }
 }
 
-void Messages::Emit(llvm::raw_ostream &o, const CookedSource &cooked,
+void Messages::Emit(llvm::raw_ostream &o, const AllCookedSources &allCooked,
     bool echoSourceLines) const {
   std::vector<const Message *> sorted;
   for (const auto &msg : messages_) {
     sorted.push_back(&msg);
   }
   std::stable_sort(sorted.begin(), sorted.end(),
       [](const Message *x, const Message *y) { return x->SortBefore(*y); });
   for (const Message *msg : sorted) {
-    msg->Emit(o, cooked, echoSourceLines);
+    msg->Emit(o, allCooked, echoSourceLines);
   }
 }
 
 void Messages::AttachTo(Message &msg) {
   for (Message &m : messages_) {
     msg.Attach(std::move(m));
   }
   messages_.clear();

flang/lib/Parser/parsing.cpp

 #include "type-parsers.h"
 #include "flang/Parser/message.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace Fortran::parser {
 
-Parsing::Parsing(AllSources &s) : cooked_{s} {}
+Parsing::Parsing(AllCookedSources &allCooked) : allCooked_{allCooked} {}
 Parsing::~Parsing() {}
 
 const SourceFile *Parsing::Prescan(const std::string &path, Options options) {
   options_ = options;
-  AllSources &allSources{cooked_.allSources()};
+  AllSources &allSources{allCooked_.allSources()};
   if (options.isModuleFile) {
     for (const auto &path : options.searchDirectories) {
       allSources.PushSearchPathDirectory(path);
     }
   }
 
   std::string buf;
   llvm::raw_string_ostream fileError{buf};
const SourceFile *Parsing::Prescan(const std::string &path, Options options) {
   Preprocessor preprocessor{allSources};
   for (const auto &predef : options.predefinitions) {
     if (predef.second) {
       preprocessor.Define(predef.first, *predef.second);
     } else {
       preprocessor.Undefine(predef.first);
     }
   }
-  Prescanner prescanner{messages_, cooked_, preprocessor, options.features};
+  currentCooked_ = &allCooked_.NewCookedSource();
+  Prescanner prescanner{
+      messages_, *currentCooked_, allSources, preprocessor, options.features};
   prescanner.set_fixedForm(options.isFixedForm)
       .set_fixedFormColumnLimit(options.fixedFormColumns)
       .AddCompilerDirectiveSentinel("dir$");
   if (options.features.IsEnabled(LanguageFeature::OpenACC)) {
     prescanner.AddCompilerDirectiveSentinel("$acc");
   }
   if (options.features.IsEnabled(LanguageFeature::OpenMP)) {
     prescanner.AddCompilerDirectiveSentinel("$omp");
     prescanner.AddCompilerDirectiveSentinel("$"); // OMP conditional line
   }
   ProvenanceRange range{allSources.AddIncludedFile(
       *sourceFile, ProvenanceRange{}, options.isModuleFile)};
   prescanner.Prescan(range);
-  if (cooked_.BufferedBytes() == 0 && !options.isModuleFile) {
+  if (currentCooked_->BufferedBytes() == 0 && !options.isModuleFile) {
     // Input is empty.  Append a newline so that any warning
     // message about nonstandard usage will have provenance.
-    cooked_.Put('\n', range.start());
+    currentCooked_->Put('\n', range.start());
   }
-  cooked_.Marshal();
+  currentCooked_->Marshal(allSources);
   if (options.needProvenanceRangeToCharBlockMappings) {
-    cooked_.CompileProvenanceRangeToOffsetMappings();
+    currentCooked_->CompileProvenanceRangeToOffsetMappings(allSources);
   }
   return sourceFile;
 }
 
 void Parsing::DumpCookedChars(llvm::raw_ostream &out) const {
-  UserState userState{cooked_, common::LanguageFeatureControl{}};
-  ParseState parseState{cooked_};
+  UserState userState{allCooked_, common::LanguageFeatureControl{}};
+  ParseState parseState{cooked()};
   parseState.set_inFixedForm(options_.isFixedForm).set_userState(&userState);
   while (std::optional<const char *> p{parseState.GetNextChar()}) {
     out << **p;
   }
 }
 
 void Parsing::DumpProvenance(llvm::raw_ostream &out) const {
-  cooked_.Dump(out);
+  allCooked_.Dump(out);
 }
 
 void Parsing::DumpParsingLog(llvm::raw_ostream &out) const {
-  log_.Dump(out, cooked_);
+  log_.Dump(out, allCooked_);
 }
 
 void Parsing::Parse(llvm::raw_ostream &out) {
-  UserState userState{cooked_, options_.features};
+  UserState userState{allCooked_, options_.features};
   userState.set_debugOutput(out)
       .set_instrumentedParse(options_.instrumentedParse)
       .set_log(&log_);
-  ParseState parseState{cooked_};
+  ParseState parseState{cooked()};
   parseState.set_inFixedForm(options_.isFixedForm).set_userState(&userState);
   parseTree_ = program.Parse(parseState);
   CHECK(
       !parseState.anyErrorRecovery() || parseState.messages().AnyFatalError());
   consumedWholeFile_ = parseState.IsAtEnd();
   messages_.Annex(std::move(parseState.messages()));
   finalRestingPlace_ = parseState.GetLocation();
 }
 
 void Parsing::ClearLog() { log_.clear(); }
 
 } // namespace Fortran::parser

flang/lib/Parser/prescan.h

 
 namespace Fortran::parser {
 
 class Messages;
 class Preprocessor;
 
 class Prescanner {
 public:
-  Prescanner(Messages &, CookedSource &, Preprocessor &,
+  Prescanner(Messages &, CookedSource &, AllSources &, Preprocessor &,
       common::LanguageFeatureControl);
   Prescanner(const Prescanner &);
 
   Messages &messages() const { return messages_; }
 
   Prescanner &set_fixedForm(bool yes) {
     inFixedForm_ = yes;
     return *this;
public:
 
   // Callbacks for use by Preprocessor.
   bool IsAtEnd() const { return nextLine_ >= limit_; }
   bool IsNextLinePreprocessorDirective() const;
   TokenSequence TokenizePreprocessorDirective();
   Provenance GetCurrentProvenance() const { return GetProvenance(at_); }
 
   template <typename... A> Message &Say(A &&...a) {
-    Message &m{messages_.Say(std::forward<A>(a)...)};
-    std::optional<ProvenanceRange> range{m.GetProvenanceRange(cooked_)};
-    CHECK(!range || cooked_.IsValid(*range));
-    return m;
+    return messages_.Say(std::forward<A>(a)...);
   }
 
 private:
   struct LineClassification {
     enum class Kind {
       Comment,
       ConditionalCompilationDirective,
       IncludeDirective, // #include
ProvenanceRange GetProvenanceRange(
     return {startProvenance_ + (first - start_), bytes};
   }
 
   void EmitChar(TokenSequence &tokens, char ch) {
     tokens.PutNextTokenChar(ch, GetCurrentProvenance());
   }
 
   void EmitInsertedChar(TokenSequence &tokens, char ch) {
-    Provenance provenance{cooked_.allSources().CompilerInsertionProvenance(ch)};
+    Provenance provenance{allSources_.CompilerInsertionProvenance(ch)};
     tokens.PutNextTokenChar(ch, provenance);
   }
 
   char EmitCharAndAdvance(TokenSequence &tokens, char ch) {
     EmitChar(tokens, ch);
     NextChar();
     return *at_;
   }
private:
   std::optional<LineClassification> IsFreeFormCompilerDirectiveLine(
       const char *) const;
   const char *IsCompilerDirectiveSentinel(const char *) const;
   LineClassification ClassifyLine(const char *) const;
   void SourceFormChange(std::string &&);
 
   Messages &messages_;
   CookedSource &cooked_;
+  AllSources &allSources_;
   Preprocessor &preprocessor_;
   common::LanguageFeatureControl features_;
   bool inFixedForm_{false};
   int fixedFormColumnLimit_{72};
   Encoding encoding_{Encoding::UTF_8};
   int delimiterNesting_{0};
   int prescannerNesting_{0};
 
private:
   // before a INCLUDE or #include, we delete it and omit the newline, so
   // that the first line of the included file is truly a continuation of
   // the line before.  Also used when the & appears at the end of the last
   // line in an include file.
   bool omitNewline_{false};
   bool skipLeadingAmpersand_{false};
 
   const Provenance spaceProvenance_{
-      cooked_.allSources().CompilerInsertionProvenance(' ')};
+      allSources_.CompilerInsertionProvenance(' ')};
   const Provenance backslashProvenance_{
-      cooked_.allSources().CompilerInsertionProvenance('\\')};
+      allSources_.CompilerInsertionProvenance('\\')};
 
   // To avoid probing the set of active compiler directive sentinel strings
   // on every comment line, they're checked first with a cheap Bloom filter.
   static const int prime1{1019}, prime2{1021};
   std::bitset<prime2> compilerDirectiveBloomFilter_; // 128 bytes
   std::unordered_set<std::string> compilerDirectiveSentinels_;
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PRESCAN_H_

flang/lib/Parser/prescan.cpp

 
 namespace Fortran::parser {
 
 using common::LanguageFeature;
 
 static constexpr int maxPrescannerNesting{100};
 
 Prescanner::Prescanner(Messages &messages, CookedSource &cooked,
-    Preprocessor &preprocessor, common::LanguageFeatureControl lfc)
-    : messages_{messages}, cooked_{cooked}, preprocessor_{preprocessor},
-      features_{lfc}, encoding_{cooked.allSources().encoding()} {}
+    AllSources &allSources, Preprocessor &preprocessor,
+    common::LanguageFeatureControl lfc)
+    : messages_{messages}, cooked_{cooked}, allSources_{allSources},
+      preprocessor_{preprocessor}, features_{lfc},
+      encoding_{allSources_.encoding()} {}
 
 Prescanner::Prescanner(const Prescanner &that)
     : messages_{that.messages_}, cooked_{that.cooked_},
-      preprocessor_{that.preprocessor_}, features_{that.features_},
-      inFixedForm_{that.inFixedForm_},
+      allSources_{that.allSources_}, preprocessor_{that.preprocessor_},
+      features_{that.features_}, inFixedForm_{that.inFixedForm_},
       fixedFormColumnLimit_{that.fixedFormColumnLimit_},
       encoding_{that.encoding_}, prescannerNesting_{that.prescannerNesting_ +
                                      1},
       skipLeadingAmpersand_{that.skipLeadingAmpersand_},
       compilerDirectiveBloomFilter_{that.compilerDirectiveBloomFilter_},
       compilerDirectiveSentinels_{that.compilerDirectiveSentinels_} {}
 
 static inline constexpr bool IsFixedFormCommentChar(char ch) {
if (*p != ' ') {
       *p = '!';
       return;
     }
   }
   DIE("compiler directive all blank");
 }
 
 void Prescanner::Prescan(ProvenanceRange range) {
-  AllSources &allSources{cooked_.allSources()};
   startProvenance_ = range.start();
   std::size_t offset{0};
-  const SourceFile *source{allSources.GetSourceFile(startProvenance_, &offset)};
+  const SourceFile *source{
+      allSources_.GetSourceFile(startProvenance_, &offset)};
   CHECK(source);
   start_ = source->content().data() + offset;
   limit_ = start_ + range.size();
   nextLine_ = start_;
   const bool beganInFixedForm{inFixedForm_};
   if (prescannerNesting_ > maxPrescannerNesting) {
     Say(GetProvenance(start_),
         "too many nested INCLUDE/#include files, possibly circular"_err_en_US);
     return;
   }
   while (nextLine_ < limit_) {
     Statement();
   }
   if (inFixedForm_ != beganInFixedForm) {
     std::string dir{"!dir$ "};
     if (beganInFixedForm) {
       dir += "fixed";
     } else {
       dir += "free";
     }
     dir += '\n';
-    TokenSequence tokens{dir, allSources.AddCompilerInsertion(dir).start()};
+    TokenSequence tokens{dir, allSources_.AddCompilerInsertion(dir).start()};
     tokens.Emit(cooked_);
   }
 }
 
 void Prescanner::Statement() {
   TokenSequence tokens;
   LineClassification line{ClassifyLine(nextLine_)};
   switch (line.kind) {
if (*p != '\n' && *p != '!') {
     for (; *p != '\n' && *p != '!'; ++p) {
     }
     Say(GetProvenanceRange(garbage, p),
         "excess characters after path name"_en_US);
   }
   std::string buf;
   llvm::raw_string_ostream error{buf};
   Provenance provenance{GetProvenance(nextLine_)};
-  AllSources &allSources{cooked_.allSources()};
-  const SourceFile *currentFile{allSources.GetSourceFile(provenance)};
+  const SourceFile *currentFile{allSources_.GetSourceFile(provenance)};
   if (currentFile) {
-    allSources.PushSearchPathDirectory(DirectoryName(currentFile->path()));
+    allSources_.PushSearchPathDirectory(DirectoryName(currentFile->path()));
   }
-  const SourceFile *included{allSources.Open(path, error)};
+  const SourceFile *included{allSources_.Open(path, error)};
   if (currentFile) {
-    allSources.PopSearchPathDirectory();
+    allSources_.PopSearchPathDirectory();
   }
   if (!included) {
     Say(provenance, "INCLUDE: %s"_err_en_US, error.str());
   } else if (included->bytes() > 0) {
     ProvenanceRange includeLineRange{
         provenance, static_cast<std::size_t>(p - nextLine_)};
     ProvenanceRange fileRange{
-        allSources.AddIncludedFile(*included, includeLineRange)};
+        allSources_.AddIncludedFile(*included, includeLineRange)};
     Prescanner{*this}.set_encoding(included->encoding()).Prescan(fileRange);
   }
 }
 
 const char *Prescanner::IsPreprocessorDirectiveLine(const char *start) const {
   const char *p{start};
   for (; *p == ' '; ++p) {
   }

flang/lib/Parser/provenance.cpp

if (at < origin_[mid].covers.start()) {
       count -= mid - low;
       low = mid;
     }
   }
   CHECK(origin_[low].covers.Contains(at));
   return origin_[low];
 }
 
-CookedSource::CookedSource(AllSources &s) : allSources_{s} {}
-CookedSource::~CookedSource() {}
-
 std::optional<ProvenanceRange> CookedSource::GetProvenanceRange(
     CharBlock cookedRange) const {
-  if (!IsValid(cookedRange)) {
+  if (!Contains(cookedRange)) {
     return std::nullopt;
   }
   ProvenanceRange first{provenanceMap_.Map(cookedRange.begin() - &data_[0])};
   if (cookedRange.size() <= first.size()) {
     return first.Prefix(cookedRange.size());
   }
   ProvenanceRange last{provenanceMap_.Map(cookedRange.end() - &data_[0])};
   return {ProvenanceRange{first.start(), last.start() - first.start()}};
 }
 
-std::optional<CharBlock> CookedSource::GetCharBlockFromLineAndColumns(
-    int line, int startColumn, int endColumn) const {
-  // 2nd column is exclusive, meaning it is target column + 1.
-  CHECK(line > 0 && startColumn > 0 && endColumn > 0);
-  CHECK(startColumn < endColumn);
-  auto provenanceStart{allSources_.GetFirstFileProvenance().value().start()};
-  if (auto sourceFile{allSources_.GetSourceFile(provenanceStart)}) {
-    CHECK(line <= static_cast<int>(sourceFile->lines()));
-    return GetCharBlock(ProvenanceRange(sourceFile->GetLineStartOffset(line) +
-            provenanceStart.offset() + startColumn - 1,
-        endColumn - startColumn));
-  }
-  return std::nullopt;
-}
-
-std::optional<std::pair<SourcePosition, SourcePosition>>
-CookedSource::GetSourcePositionRange(CharBlock cookedRange) const {
-  if (auto range{GetProvenanceRange(cookedRange)}) {
-    if (auto firstOffset{allSources_.GetSourcePosition(range->start())}) {
-      if (auto secondOffset{
-              allSources_.GetSourcePosition(range->start() + range->size())}) {
-        return std::pair{*firstOffset, *secondOffset};
-      }
-    }
-  }
-  return std::nullopt;
-}
-
 std::optional<CharBlock> CookedSource::GetCharBlock(
     ProvenanceRange range) const {
   CHECK(!invertedMap_.empty() &&
       "CompileProvenanceRangeToOffsetMappings not called");
   if (auto to{invertedMap_.Map(range)}) {
     return CharBlock{data_.c_str() + *to, range.size()};
   } else {
     return std::nullopt;
   }
 }
 
 std::size_t CookedSource::BufferedBytes() const { return buffer_.bytes(); }
 
-void CookedSource::Marshal() {
+void CookedSource::Marshal(AllSources &allSources) {
   CHECK(provenanceMap_.SizeInBytes() == buffer_.bytes());
-  provenanceMap_.Put(allSources_.AddCompilerInsertion("(after end of source)"));
+  provenanceMap_.Put(allSources.AddCompilerInsertion("(after end of source)"));
   data_ = buffer_.Marshal();
   buffer_.clear();
 }
 
-void CookedSource::CompileProvenanceRangeToOffsetMappings() {
+void CookedSource::CompileProvenanceRangeToOffsetMappings(
+    AllSources &allSources) {
   if (invertedMap_.empty()) {
-    invertedMap_ = provenanceMap_.Invert(allSources_);
+    invertedMap_ = provenanceMap_.Invert(allSources);
   }
 }
 
 static void DumpRange(llvm::raw_ostream &o, const ProvenanceRange &r) {
   o << "[" << r.start().offset() << ".." << r.Last().offset() << "] ("
     << r.size() << " bytes)";
 }
 
if (IsValid(m.replaces)) {
       DumpRange(o, m.replaces);
     }
     o << '\n';
   }
   return o;
 }
 
 llvm::raw_ostream &CookedSource::Dump(llvm::raw_ostream &o) const {
-  o << "CookedSource:\n";
-  allSources_.Dump(o);
   o << "CookedSource::provenanceMap_:\n";
   provenanceMap_.Dump(o);
   o << "CookedSource::invertedMap_:\n";
   invertedMap_.Dump(o);
   return o;
 }
+
+AllCookedSources::AllCookedSources(AllSources &s) : allSources_{s} {}
+AllCookedSources::~AllCookedSources() {}
+
+CookedSource &AllCookedSources::NewCookedSource() {
+  return cooked_.emplace_back();
+}
+
+std::optional<ProvenanceRange> AllCookedSources::GetProvenanceRange(
+    CharBlock cb) const {
+  if (const CookedSource * c{Find(cb)}) {
+    return c->GetProvenanceRange(cb);
+  } else {
+    return std::nullopt;
+  }
+}
+
+std::optional<CharBlock> AllCookedSources::GetCharBlockFromLineAndColumns(
+    int line, int startColumn, int endColumn) const {
+  // 2nd column is exclusive, meaning it is target column + 1.
+  CHECK(line > 0 && startColumn > 0 && endColumn > 0);
+  CHECK(startColumn < endColumn);
+  auto provenanceStart{allSources_.GetFirstFileProvenance().value().start()};
+  if (auto sourceFile{allSources_.GetSourceFile(provenanceStart)}) {
+    CHECK(line <= static_cast<int>(sourceFile->lines()));
+    return GetCharBlock(ProvenanceRange(sourceFile->GetLineStartOffset(line) +
+            provenanceStart.offset() + startColumn - 1,
+        endColumn - startColumn));
+  }
+  return std::nullopt;
+}
+
+std::optional<std::pair<SourcePosition, SourcePosition>>
+AllCookedSources::GetSourcePositionRange(CharBlock cookedRange) const {
+  if (auto range{GetProvenanceRange(cookedRange)}) {
+    if (auto firstOffset{allSources_.GetSourcePosition(range->start())}) {
+      if (auto secondOffset{
+              allSources_.GetSourcePosition(range->start() + range->size())}) {
+        return std::pair{*firstOffset, *secondOffset};
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+std::optional<CharBlock> AllCookedSources::GetCharBlock(
+    ProvenanceRange range) const {
+  for (const auto &c : cooked_) {
+    if (auto result{c.GetCharBlock(range)}) {
+      return result;
+    }
+  }
+  return nullptr;
+}
+
+void AllCookedSources::Dump(llvm::raw_ostream &o) const {
+  o << "AllSources:\n";
+  allSources_.Dump(o);
+  for (const auto &c : cooked_) {
+    c.Dump(o);
+  }
+}
+
 } // namespace Fortran::parser

flang/lib/Semantics/mod-file.cpp

if (ancestor) {
     }
     ancestorName = ancestor->GetName().value().ToString();
   } else {
     auto it{context_.globalScope().find(name)};
     if (it != context_.globalScope().end()) {
       return it->second->scope();
     }
   }
-  parser::Parsing parsing{context_.allSources()};
+  parser::Parsing parsing{context_.allCookedSources()};
   parser::Options options;
   options.isModuleFile = true;
   options.features.Enable(common::LanguageFeature::BackslashEscapes);
   options.searchDirectories = context_.searchDirectories();
   auto path{ModFileName(name, ancestorName, context_.moduleFileSuffix())};
   const auto *sourceFile{parsing.Prescan(path, options)};
   if (parsing.messages().AnyFatalError()) {
     for (auto &msg : parsing.messages().messages()) {
Scope *ModFileReader::Read(const SourceName &name, Scope *ancestor) {
   }
   ResolveNames(context_, *parseTree);
   const auto &it{parentScope->find(name)};
   if (it == parentScope->end()) {
     return nullptr;
   }
   auto &modSymbol{*it->second};
   modSymbol.set(Symbol::Flag::ModFile);
-  modSymbol.scope()->set_chars(parsing.cooked());
   return modSymbol.scope();
 }
 
 parser::Message &ModFileReader::Say(const SourceName &name,
     const std::string &ancestor, parser::MessageFixedText &&msg,
     const std::string &arg) {
   return context_
       .Say(name,

flang/lib/Semantics/scope.cpp

return declTypeSpecs_.emplace_back(
       CharacterTypeSpec{std::move(length), std::move(kind)});
 }
 
 DeclTypeSpec &Scope::MakeDerivedType(
     DeclTypeSpec::Category category, DerivedTypeSpec &&spec) {
   return declTypeSpecs_.emplace_back(category, std::move(spec));
 }
 
-void Scope::set_chars(parser::CookedSource &cooked) {
-  CHECK(kind_ == Kind::Module);
-  CHECK(parent_.IsGlobal() || parent_.IsModuleFile());
-  CHECK(DEREF(symbol_).test(Symbol::Flag::ModFile));
-  // TODO: Preserve the CookedSource rather than acquiring its string.
-  chars_ = cooked.AcquireData();
-}
-
 Scope::ImportKind Scope::GetImportKind() const {
   if (importKind_) {
     return *importKind_;
   }
   if (symbol_ && !symbol_->attrs().test(Attr::MODULE)) {
     if (auto *details{symbol_->detailsIf<SubprogramDetails>()}) {
       if (details->isInterface()) {
         return ImportKind::None; // default for non-mod-proc interface body

flang/lib/Semantics/semantics.cpp

if (!context.AnyFatalError()) {
     pass2.CompileDataInitializationsIntoInitializers();
   }
   return !context.AnyFatalError();
 }
 
 SemanticsContext::SemanticsContext(
     const common::IntrinsicTypeDefaultKinds &defaultKinds,
     const common::LanguageFeatureControl &languageFeatures,
-    parser::AllSources &allSources)
+    parser::AllCookedSources &allCookedSources)
     : defaultKinds_{defaultKinds}, languageFeatures_{languageFeatures},
-      allSources_{allSources},
+      allCookedSources_{allCookedSources},
       intrinsics_{evaluate::IntrinsicProcTable::Configure(defaultKinds_)},
       foldingContext_{
           parser::ContextualMessages{&messages_}, defaultKinds_, intrinsics_} {}
 
 SemanticsContext::~SemanticsContext() {}
 
 int SemanticsContext::GetDefaultKind(TypeCategory category) const {
   return defaultKinds_.GetDefaultKind(category);
return ValidateLabels(context_, program_) &&
       parser::CanonicalizeDo(program_) && // force line break
       CanonicalizeAcc(context_.messages(), program_) &&
       CanonicalizeOmp(context_.messages(), program_) &&
       PerformStatementSemantics(context_, program_) &&
       ModFileWriter{context_}.WriteAll();
 }
 
 void Semantics::EmitMessages(llvm::raw_ostream &os) const {
-  context_.messages().Emit(os, cooked_);
+  context_.messages().Emit(os, context_.allCookedSources());
 }
 
 void Semantics::DumpSymbols(llvm::raw_ostream &os) {
   DoDumpSymbols(os, context_.globalScope());
 }
 
 void Semantics::DumpSymbolsSources(llvm::raw_ostream &os) const {
   NameToSymbolMap symbols;
   GetSymbolNames(context_.globalScope(), symbols);
+  const parser::AllCookedSources &allCooked{context_.allCookedSources()};
   for (const auto &pair : symbols) {
     const Symbol &symbol{pair.second};
-    if (auto sourceInfo{cooked_.GetSourcePositionRange(symbol.name())}) {
+    if (auto sourceInfo{allCooked.GetSourcePositionRange(symbol.name())}) {
       os << symbol.name().ToString() << ": " << sourceInfo->first.file.path()
          << ", " << sourceInfo->first.line << ", " << sourceInfo->first.column
          << "-" << sourceInfo->second.column << "\n";
     } else if (symbol.has<semantics::UseDetails>()) {
       os << symbol.name().ToString() << ": "
          << symbol.GetUltimate().owner().symbol()->name().ToString() << "\n";
     }
   }

flang/test/Semantics/getsymbols02.f90

 ! Tests -fget-symbols-sources with modules.
 
 PROGRAM helloworld
     use mm2b
     implicit none
     integer::i
     i = callget5()
 ENDPROGRAM
 
 ! RUN: %f18 -fparse-only %S/Inputs/getsymbols02-a.f90
 ! RUN: %f18 -fparse-only %S/Inputs/getsymbols02-b.f90
 ! RUN: %f18 -fget-symbols-sources -fparse-only %s 2>&1 | FileCheck %s
-! CHECK: callget5: mm2b
-! CHECK: get5: mm2a
+! CHECK: callget5: ./mm2b.mod,
+! CHECK: get5: ./mm2a.mod,

flang/tools/f18-parse-demo/f18-parse-demo.cpp

if (!driver.forcedForm) {
     auto dot{path.rfind(".")};
     if (dot != std::string::npos) {
       std::string suffix{path.substr(dot + 1)};
       options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
     }
   }
   options.searchDirectories = driver.searchDirectories;
   Fortran::parser::AllSources allSources;
-  Fortran::parser::Parsing parsing{allSources};
+  Fortran::parser::AllCookedSources allCookedSources{allSources};
+  Fortran::parser::Parsing parsing{allCookedSources};
 
   auto start{CPUseconds()};
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
     llvm::errs() << driver.prefix << "could not scan " << path << '\n';
-    parsing.messages().Emit(llvm::errs(), parsing.cooked());
+    parsing.messages().Emit(llvm::errs(), parsing.allCooked());
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if (driver.dumpProvenance) {
     parsing.DumpProvenance(llvm::outs());
     return {};
   }
   if (driver.dumpCookedChars) {
     parsing.DumpCookedChars(llvm::outs());
     return {};
   }
   parsing.Parse(llvm::outs());
   auto stop{CPUseconds()};
   if (driver.timeParse) {
     if (canTime) {
       llvm::outs() << "parse time for " << path << ": " << (stop - start)
                    << " CPU seconds\n";
     } else {
       llvm::outs() << "no timing information due to lack of clock_gettime()\n";
     }
   }
 
   parsing.ClearLog();
-  parsing.messages().Emit(llvm::errs(), parsing.cooked());
+  parsing.messages().Emit(llvm::errs(), parsing.allCooked());
   if (!parsing.consumedWholeFile()) {
     parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
         "parser FAIL (final position)");
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if ((!parsing.messages().empty() &&
           (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||

flang/tools/f18/f18.cpp

[](llvm::raw_ostream &o, const Fortran::evaluate::ProcedureRef &x) {
       x.AsFortran(o << "CALL ");
     },
 };
 
 std::string CompileFortran(std::string path, Fortran::parser::Options options,
     DriverOptions &driver,
     const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds) {
   Fortran::parser::AllSources allSources;
+  Fortran::parser::AllCookedSources allCookedSources{allSources};
   allSources.set_encoding(driver.encoding);
   Fortran::semantics::SemanticsContext semanticsContext{
-      defaultKinds, options.features, allSources};
+      defaultKinds, options.features, allCookedSources};
   semanticsContext.set_moduleDirectory(driver.moduleDirectory)
       .set_moduleFileSuffix(driver.moduleFileSuffix)
       .set_searchDirectories(driver.searchDirectories)
       .set_warnOnNonstandardUsage(driver.warnOnNonstandardUsage)
       .set_warningsAreErrors(driver.warningsAreErrors);
   if (!driver.forcedForm) {
     auto dot{path.rfind(".")};
     if (dot != std::string::npos) {
       std::string suffix{path.substr(dot + 1)};
       options.isFixedForm = suffix == "f" || suffix == "F" || suffix == "ff";
     }
   }
   options.searchDirectories = driver.searchDirectories;
-  Fortran::parser::Parsing parsing{semanticsContext.allSources()};
+  Fortran::parser::Parsing parsing{allCookedSources};
   parsing.Prescan(path, options);
   if (!parsing.messages().empty() &&
       (driver.warningsAreErrors || parsing.messages().AnyFatalError())) {
     llvm::errs() << driver.prefix << "could not scan " << path << '\n';
-    parsing.messages().Emit(llvm::errs(), parsing.cooked());
+    parsing.messages().Emit(llvm::errs(), allCookedSources);
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if (driver.dumpProvenance) {
     parsing.DumpProvenance(llvm::outs());
     return {};
   }
   if (driver.dumpCookedChars) {
-    parsing.messages().Emit(llvm::errs(), parsing.cooked());
+    parsing.messages().Emit(llvm::errs(), allCookedSources);
     parsing.DumpCookedChars(llvm::outs());
     return {};
   }
   parsing.Parse(llvm::outs());
   if (options.instrumentedParse) {
     parsing.DumpParsingLog(llvm::outs());
     return {};
   }
   parsing.ClearLog();
-  parsing.messages().Emit(llvm::errs(), parsing.cooked());
+  parsing.messages().Emit(llvm::errs(), allCookedSources);
   if (!parsing.consumedWholeFile()) {
     parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
         "parser FAIL (final position)");
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if ((!parsing.messages().empty() &&
           (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
if (driver.dumpUnparseWithSymbols) {
           llvm::outs(), parseTree, driver.encoding);
       return {};
     }
     if (driver.getSymbolsSources) {
       semantics.DumpSymbolsSources(llvm::outs());
       return {};
     }
     if (driver.getDefinition) {
-      if (auto cb{parsing.cooked().GetCharBlockFromLineAndColumns(
+      if (auto cb{allCookedSources.GetCharBlockFromLineAndColumns(
               driver.getDefinitionArgs.line,
               driver.getDefinitionArgs.startColumn,
               driver.getDefinitionArgs.endColumn)}) {
         llvm::errs() << "String range: >" << cb->ToString() << "<\n";
         if (auto symbol{semanticsContext.FindScope(*cb).FindSymbol(*cb)}) {
           llvm::errs() << "Found symbol name: " << symbol->name().ToString()
                        << "\n";
           if (auto sourceInfo{
-                  parsing.cooked().GetSourcePositionRange(symbol->name())}) {
+                  allCookedSources.GetSourcePositionRange(symbol->name())}) {
             llvm::outs() << symbol->name().ToString() << ": "
                          << sourceInfo->first.file.path() << ", "
                          << sourceInfo->first.line << ", "
                          << sourceInfo->first.column << "-"
                          << sourceInfo->second.column << "\n";
             exitStatus = EXIT_SUCCESS;
             return {};
           }

flang/unittests/Evaluate/intrinsics.cpp

public:
   explicit CookedStrings(const std::initializer_list<std::string> &ss) {
     for (const auto &s : ss) {
       Save(s);
     }
     Marshal();
   }
   void Save(const std::string &s) {
     offsets_[s] = cooked_.Put(s);
-    cooked_.PutProvenance(cooked_.allSources().AddCompilerInsertion(s));
+    cooked_.PutProvenance(allSources_.AddCompilerInsertion(s));
   }
-  void Marshal() { cooked_.Marshal(); }
+  void Marshal() { cooked_.Marshal(allSources_); }
   parser::CharBlock operator()(const std::string &s) {
     return {cooked_.data().data() + offsets_[s], s.size()};
   }
   parser::ContextualMessages Messages(parser::Messages &buffer) {
     return parser::ContextualMessages{cooked_.data(), &buffer};
   }
   void Emit(llvm::raw_ostream &o, const parser::Messages &messages) {
-    messages.Emit(o, cooked_);
+    messages.Emit(o, allCookedSources_);
   }
 
 private:
   parser::AllSources allSources_;
-  parser::CookedSource cooked_{allSources_};
+  parser::AllCookedSources allCookedSources_{allSources_};
+  parser::CookedSource &cooked_{allCookedSources_.NewCookedSource()};
   std::map<std::string, std::size_t> offsets_;
 };
 
 template <typename A> auto Const(A &&x) -> Constant<TypeOf<A>> {
   return Constant<TypeOf<A>>{std::move(x)};
 }
 
 template <typename A> struct NamedArg {