Make Decl:: setOwningModuleID() public. (NFC)

[aprantl]

Summary

This API is going to be used by LLDB to recreate owning module information for Decls deserializwed from DWARF. Because of the assertion I also need to make setFromASTFile public. Alternatively, we could remove the assertion.

[rsmith]

clang/include/clang/AST/DeclBase.h

629–630

Setting this after creating a Decl is not safe in general; declarations with this flag set have 8 bytes of additional storage allocated before their start.

An assert(FromASTFile || hasLocalOwningModuleStorage()); would at least catch the unsafe cases. This also needs a comment saying that it's not safe to use in general, and perhaps a scarier name to discourage people from calling it. (Unless you're creating declarations with ::CreateDeserialized -- in which case you'd need all the Decl subclasses to befriend the creator, making this function unnecessary -- this is currently only going to be safe if ModulesLocalVisibility is enabled.)

[aprantl]

I took your suggestion to heart and changed the downstream LLDB patch to use CreateDeserialized() everywhere, which is frankly a better fit there anyway. To make this possible I had to make a few more setters public, see the updated patch.

I also discovered that DeclBase::operator new() now always allocates 2*4 bytes extra storage. I think it needs to do this for local submodule visibility. This makes my change to CreateDeserialized() not strictly necessary, but I think it is better anyway.

[aprantl]

clang/include/clang/AST/DeclBase.h

629–630

I think the warning is unnecessary, since the storage is always allocated. Please let me know if I misunderstood something.

[rsmith]

I'm surprised so few setters needed to be made public for this to work. If this required making lots more setters public, I'd be concerned, because we generally don't want large chunks of the AST to be mutable after creation. But this seems fine.

clang/include/clang/AST/DeclBase.h

629–630

The storage isn't necessarily allocated if the decl is created with ::Create rather than ::CreateDeserialized. Just changing the comment to say the declaration must have been created with CreateDeserialized would be fine.

[shafik]

LGTM

clang/include/clang/AST/Decl.h

     EnumDeclBits.NumPositiveBits = Num;
     assert(EnumDeclBits.NumPositiveBits == Num && "can't store this bitcount");
   }
 
   /// Returns the width in bits required to store all the
   /// negative enumerators of this enum. (see getNumNegativeBits)
   void setNumNegativeBits(unsigned Num) { EnumDeclBits.NumNegativeBits = Num; }
 
+public:
   /// True if this tag declaration is a scoped enumeration. Only
   /// possible in C++11 mode.
   void setScoped(bool Scoped = true) { EnumDeclBits.IsScoped = Scoped; }
 
   /// If this tag declaration is a scoped enum,
   /// then this is true if the scoped enum was declared using the class
   /// tag, false if it was declared with the struct tag. No meaning is
   /// associated if this tag declaration is not a scoped enum.
   void setScopedUsingClassTag(bool ScopedUCT = true) {
     EnumDeclBits.IsScopedUsingClassTag = ScopedUCT;
   }
 
   /// True if this is an Objective-C, C++11, or
   /// Microsoft-style enumeration with a fixed underlying type.
   void setFixed(bool Fixed = true) { EnumDeclBits.IsFixed = Fixed; }
 
+private:
   /// True if a valid hash is stored in ODRHash.
   bool hasODRHash() const { return EnumDeclBits.HasODRHash; }
   void setHasODRHash(bool Hash = true) { EnumDeclBits.HasODRHash = Hash; }
 
 public:
   friend class ASTDeclReader;
 
   EnumDecl *getCanonicalDecl() override {

clang/include/clang/AST/DeclBase.h

protected:
   void setModulePrivate() {
     // The module-private specifier has no effect on unowned declarations.
     // FIXME: We should track this in some way for source fidelity.
     if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned)
       return;
     setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate);
   }
 
-  /// Set the owning module ID.
+public:
+  /// Set the FromASTFile flag. This indicates that this declaration
+  /// was deserialized and not parsed from source code and enables
+  /// features such as module ownership information.
+  void setFromASTFile() {
+    FromASTFile = true;
+  }
+
+  /// Set the owning module ID.  This may only be called for
+  /// deserialized Decls.
   void setOwningModuleID(unsigned ID) {
     assert(isFromASTFile() && "Only works on a deserialized declaration");
     *((unsigned*)this - 2) = ID;
   }
 
 public:
   /// Determine the availability of the given declaration.
   ///

clang/include/clang/AST/DeclCXX.h

       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
                       SC_None, isInline, ConstexprKind, EndLocation,
                       TrailingRequiresClause),
         ExplicitSpec(ES) {}
   void anchor() override;
 
   ExplicitSpecifier ExplicitSpec;
 
-  void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
-
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   static CXXConversionDecl *
   Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
          bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind,
          SourceLocation EndLocation, Expr *TrailingRequiresClause = nullptr);
   static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   ExplicitSpecifier getExplicitSpecifier() {
     return getCanonicalDecl()->ExplicitSpec;
   }
 
   const ExplicitSpecifier getExplicitSpecifier() const {
     return getCanonicalDecl()->ExplicitSpec;
   }
 
   /// Return true if the declartion is already resolved to be explicit.
   bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
+  void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
 
   /// Returns the type that this conversion function is converting to.
   QualType getConversionType() const {
     return getType()->castAs<FunctionType>()->getReturnType();
   }
 
   /// Determine whether this conversion function is a conversion from
   /// a lambda closure type to a block pointer.

clang/include/clang/AST/DeclTemplate.h

   ClassTemplateDecl *getSpecializedTemplate() const;
 
   /// Retrieve the template arguments of the class template
   /// specialization.
   const TemplateArgumentList &getTemplateArgs() const {
     return *TemplateArgs;
   }
 
+  void setTemplateArgs(TemplateArgumentList *Args) {
+    TemplateArgs = Args;
+  }
+
   /// Determine the kind of specialization that this
   /// declaration represents.
   TemplateSpecializationKind getSpecializationKind() const {
     return static_cast<TemplateSpecializationKind>(SpecializationKind);
   }
 
   bool isExplicitSpecialization() const {
     return getSpecializationKind() == TSK_ExplicitSpecialization;