[clang][AST] Added some missing setter methods

[strimo378]

I added some missing (simple) setter methods to Decl and Expr classes. I did not comment them since typically simple setter methods are uncommented.

[aaron.ballman]

We typically only add these sorts of functions when we need them; do you have a need to add setters? (Oftentimes, we don't want setters because we want the AST nodes to be created in the correct state when possible; we do add some setters because of AST deserialization where we need to create an empty shell AST node and fill it out piecewise as we deserialize.)

[strimo378]

Yes, I have a need for these setters :) but I cannot decide if the LLVM project in general or other people could profit from it.

I am working on a C++-to-C transpiler based on clang. Other clang-based tool typically modify the intput file based on FileLocation information. In contrast, I follow a constructive approach with AST print. The transpiler is organized in many small passes that transform the clang AST until at the end I can output the C code via AST print. Some notable passes are

• Remove unused AST decls (simplifies AST for non-trivial input)
• Resolve templates (is also useful standalone to remove templates from a C++ program)
• Resolve namespaces
• Move nested records
• Convert methods to functions
• etc.

For transforming the AST, I often need to replace Types and regenerate the corresponding TypeLoc. I tried for over one year to recreate AST nodes when a setter methods was missing but that caused a lot of work and instabilities for maintaining cross references. For that reason, I now insert a new setter method when needed and until now surprising less setter methods are missing.

For me it takes 5-10 min per version upgrade to port the changes, so it is not a big deal for me if you refuse them. I have some other AST modification in place for removing templates information but nothing complex...

[aaron.ballman]

In D158055#4594863, @strimo378 wrote:

Yes, I have a need for these setters :) but I cannot decide if the LLVM project in general or other people could profit from it.

I am working on a C++-to-C transpiler based on clang. Other clang-based tool typically modify the intput file based on FileLocation information. In contrast, I follow a constructive approach with AST print. The transpiler is organized in many small passes that transform the clang AST until at the end I can output the C code via AST print. Some notable passes are

• Remove unused AST decls (simplifies AST for non-trivial input)
• Resolve templates (is also useful standalone to remove templates from a C++ program)
• Resolve namespaces
• Move nested records
• Convert methods to functions
• etc.

For transforming the AST, I often need to replace Types and regenerate the corresponding TypeLoc. I tried for over one year to recreate AST nodes when a setter methods was missing but that caused a lot of work and instabilities for maintaining cross references. For that reason, I now insert a new setter method when needed and until now surprising less setter methods are missing.

For me it takes 5-10 min per version upgrade to port the changes, so it is not a big deal for me if you refuse them. I have some other AST modification in place for removing templates information but nothing complex...

Thank you for the detailed explanation! I think we should probably skip adding these until there's an in-tree need for them. Given that we don't want the AST to be mutable once it's been constructed, I think adding setters gives the wrong impression and we should continue to use friend to give limited access to interfaces that need the mutability.

[strimo378]

Alright, thank you for the review...

clang/include/clang/AST/Decl.h

Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
          Expr *TrailingRequiresClause);
 
   static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   DeclarationNameInfo getNameInfo() const {
     return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
   }
 
+  void setDeclNameLoc(const DeclarationNameLoc &Loc) { DNLoc = Loc; }
+
   void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
                             bool Qualified) const override;
 
   void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
 
   /// Returns the location of the ellipsis of a variadic function.
   SourceLocation getEllipsisLoc() const {
     const auto *FPT = getType()->getAs<FunctionProtoType>();
public:
 
   /// Returns the index of this field within its record,
   /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
   unsigned getFieldIndex() const;
 
   /// Determines whether this field is mutable (C++ only).
   bool isMutable() const { return Mutable; }
 
+  void setMutable(bool Mutable) { this->Mutable = Mutable; }
+
   /// Determines whether this field is a bitfield.
   bool isBitField() const { return BitField; }
 
   /// Determines whether this is an unnamed bitfield.
   bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
 
   /// Determines whether this field is a
   /// representative for an anonymous struct or union. Such fields are

clang/include/clang/AST/Expr.h

public:
   /// provided as a convenience for analyses that don't wish to
   /// precisely model the execution behavior of the program.
   ///
   /// The source expression is typically set when building the
   /// expression which binds the opaque value expression in the first
   /// place.
   Expr *getSourceExpr() const { return SourceExpr; }
 
+  void setSourceExpr(Expr *E) { SourceExpr = E; }
+
   void setIsUnique(bool V) {
     assert((!V || SourceExpr) &&
            "unique OVEs are expected to have source expressions");
     OpaqueValueExprBits.IsUnique = V;
   }
 
   bool isUnique() const { return OpaqueValueExprBits.IsUnique; }
 
public:
   /// If the name was qualified, retrieves the nested-name-specifier
   /// that precedes the name, with source-location information.
   NestedNameSpecifierLoc getQualifierLoc() const {
     if (!hasQualifier())
       return NestedNameSpecifierLoc();
     return *getTrailingObjects<NestedNameSpecifierLoc>();
   }
 
+  void setQualifierLoc(NestedNameSpecifierLoc QL) {
+    assert(hasQualifier());
+    *getTrailingObjects<NestedNameSpecifierLoc>() = QL;
+  }
+
   /// If the name was qualified, retrieves the nested-name-specifier
   /// that precedes the name. Otherwise, returns NULL.
   NestedNameSpecifier *getQualifier() const {
     return getQualifierLoc().getNestedNameSpecifier();
   }
 
   /// Get the NamedDecl through which this reference occurred.
   ///
   /// This Decl may be different from the ValueDecl actually referred to in the
   /// presence of using declarations, etc. It always returns non-NULL, and may
   /// simple return the ValueDecl when appropriate.
 
   NamedDecl *getFoundDecl() {
     return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
   }
 
   /// Get the NamedDecl through which this reference occurred.
   /// See non-const variant.
   const NamedDecl *getFoundDecl() const {
     return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
   }
 
+  void setFoundDecl(NamedDecl *ND) {
+    assert(hasFoundDecl());
+    *getTrailingObjects<NamedDecl *>() = ND;
+  }
+
   bool hasTemplateKWAndArgsInfo() const {
     return DeclRefExprBits.HasTemplateKWAndArgsInfo;
   }
 
   /// Retrieve the location of the template keyword preceding
   /// this name, if any.
   SourceLocation getTemplateKeywordLoc() const {
     if (!hasTemplateKWAndArgsInfo())
public:
   /// nested-name-specifier that precedes the member name, with source-location
   /// information.
   NestedNameSpecifierLoc getQualifierLoc() const {
     if (!hasQualifierOrFoundDecl())
       return NestedNameSpecifierLoc();
     return getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc;
   }
 
+  void setQualifierLoc(NestedNameSpecifierLoc QL) {
+    assert(hasQualifierOrFoundDecl());
+    getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc = QL;
+  }
+
   /// If the member name was qualified, retrieves the
   /// nested-name-specifier that precedes the member name. Otherwise, returns
   /// NULL.
   NestedNameSpecifier *getQualifier() const {
     return getQualifierLoc().getNestedNameSpecifier();
   }
 
   /// Retrieve the location of the template keyword preceding
public:
   }
 
   /// Retrieve the member declaration name info.
   DeclarationNameInfo getMemberNameInfo() const {
     return DeclarationNameInfo(MemberDecl->getDeclName(),
                                MemberLoc, MemberDNLoc);
   }
 
+  void setMemberDeclNameLoc(const DeclarationNameLoc &Loc) {
+    MemberDNLoc = Loc;
+  }
+
   SourceLocation getOperatorLoc() const { return MemberExprBits.OperatorLoc; }
 
   bool isArrow() const { return MemberExprBits.IsArrow; }
   void setArrow(bool A) { MemberExprBits.IsArrow = A; }
 
   /// getMemberLoc - Return the location of the "member", in X->F, it is the
   /// location of 'F'.
   SourceLocation getMemberLoc() const { return MemberLoc; }