Rename Function to Subprogram

In Fortran, a function is only a particular kind of subprogram. However,
what we'd call a function in C/C++ can be any kind of subprogram in Fortran
(even the main program, which is not really a kind of subprogram, but acts
like one in almost every way).

Author: Hal Finkel

examples/PrintFunctionNames/PrintFunctionNames.cpp

@@ -1,4 +1,4 @@
-//===- PrintFunctionNames.cpp ---------------------------------------------===//
+//===- PrintSubprogramNames.cpp ---------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -21,7 +21,7 @@ using namespace lfort;
 
 namespace {
 
-class PrintFunctionsConsumer : public ASTConsumer {
+class PrintSubprogramsConsumer : public ASTConsumer {
 public:
   virtual bool HandleTopLevelDecl(DeclGroupRef DG) {
     for (DeclGroupRef::iterator i = DG.begin(), e = DG.end(); i != e; ++i) {
@@ -34,16 +34,16 @@ class PrintFunctionsConsumer : public ASTConsumer {
   }
 };
 
-class PrintFunctionNamesAction : public PluginASTAction {
+class PrintSubprogramNamesAction : public PluginASTAction {
 protected:
   ASTConsumer *CreateASTConsumer(CompilerInstance &CI, llvm::StringRef) {
-    return new PrintFunctionsConsumer();
+    return new PrintSubprogramsConsumer();
   }
 
   bool ParseArgs(const CompilerInstance &CI,
                  const std::vector<std::string>& args) {
     for (unsigned i = 0, e = args.size(); i != e; ++i) {
-      llvm::errs() << "PrintFunctionNames arg = " << args[i] << "\n";
+      llvm::errs() << "PrintSubprogramNames arg = " << args[i] << "\n";
 
       // Example error handling.
       if (args[i] == "-an-error") {
@@ -60,12 +60,12 @@ class PrintFunctionNamesAction : public PluginASTAction {
     return true;
   }
   void PrintHelp(llvm::raw_ostream& ros) {
-    ros << "Help for PrintFunctionNames plugin goes here\n";
+    ros << "Help for PrintSubprogramNames plugin goes here\n";
   }
 
 };
 
 }
 
-static FrontendPluginRegistry::Add<PrintFunctionNamesAction>
+static FrontendPluginRegistry::Add<PrintSubprogramNamesAction>
 X("print-fns", "print function names");

examples/analyzer-plugin/MainCallChecker.cpp

@@ -19,7 +19,7 @@ void MainCallChecker::checkPreStmt(const CallExpr *CE, CheckerContext &C) const
   const ProgramStateRef state = C.getState();
   const LocationContext *LC = C.getLocationContext();
   const Expr *Callee = CE->getCallee();
-  const FunctionDecl *FD = state->getSVal(Callee, LC).getAsFunctionDecl();
+  const SubprogramDecl *FD = state->getSVal(Callee, LC).getAsSubprogramDecl();
 
   if (!FD)
     return;

examples/lfort-interpreter/main.cpp

@@ -52,7 +52,7 @@ static int Execute(llvm::Module *Mod, char * const *envp) {
     return 255;
   }
 
-  llvm::Function *EntryFn = Mod->getFunction("main");
+  llvm::Function *EntryFn = Mod->getSubprogram("main");
   if (!EntryFn) {
     llvm::errs() << "'main' function not found in module.\n";
     return 255;
@@ -62,7 +62,7 @@ static int Execute(llvm::Module *Mod, char * const *envp) {
   std::vector<std::string> Args;
   Args.push_back(Mod->getModuleIdentifier());
 
-  return EE->runFunctionAsMain(EntryFn, Args, envp);
+  return EE->runSubprogramAsMain(EntryFn, Args, envp);
 }
 
 int main(int argc, const char **argv, char * const *envp) {

include/lfort-c/Index.h

@@ -1117,7 +1117,7 @@ enum CXTranslationUnit_Flags {
    * This option can be used to search for declarations/definitions while
    * ignoring the usages.
    */
-  CXTranslationUnit_SkipFunctionBodies = 0x40,
+  CXTranslationUnit_SkipSubprogramBodies = 0x40,
 
   /**
    * \brief Used to indicate that brief documentation comments should be
@@ -1452,7 +1452,7 @@ enum CXCursorKind {
   /** \brief An enumerator constant. */
   CXCursor_EnumConstantDecl              = 7,
   /** \brief A function. */
-  CXCursor_FunctionDecl                  = 8,
+  CXCursor_SubprogramDecl                  = 8,
   /** \brief A variable. */
   CXCursor_VarDecl                       = 9,
   /** \brief A function or method parameter. */
@@ -1488,15 +1488,15 @@ enum CXCursorKind {
   /** \brief A C++ destructor. */
   CXCursor_Destructor                    = 25,
   /** \brief A C++ conversion function. */
-  CXCursor_ConversionFunction            = 26,
+  CXCursor_ConversionSubprogram            = 26,
   /** \brief A C++ template type parameter. */
   CXCursor_TemplateTypeParameter         = 27,
   /** \brief A C++ non-type template parameter. */
   CXCursor_NonTypeTemplateParameter      = 28,
   /** \brief A C++ template template parameter. */
   CXCursor_TemplateTemplateParameter     = 29,
   /** \brief A C++ function template. */
-  CXCursor_FunctionTemplate              = 30,
+  CXCursor_SubprogramTemplate              = 30,
   /** \brief A C++ class template. */
   CXCursor_ClassTemplate                 = 31,
   /** \brief A C++ class template partial specialization. */
@@ -1771,7 +1771,7 @@ enum CXCursorKind {
    *   x = int(0.5);
    * \endcode
    */
-  CXCursor_CXXFunctionalCastExpr         = 128,
+  CXCursor_CXXSubprogramalCastExpr         = 128,
 
   /** \brief A C++ typeid expression (C++ [expr.typeid]).
    */
@@ -2636,8 +2636,8 @@ enum CXTypeKind {
   CXType_Typedef = 107,
   CXType_ObjCInterface = 108,
   CXType_ObjCObjectPointer = 109,
-  CXType_FunctionNoProto = 110,
-  CXType_FunctionProto = 111,
+  CXType_SubprogramNoProto = 110,
+  CXType_SubprogramProto = 111,
   CXType_ConstantArray = 112,
   CXType_Vector = 113
 };
@@ -2799,7 +2799,7 @@ CINDEX_LINKAGE CXString lfort_getTypeKindSpelling(enum CXTypeKind K);
  *
  * If a non-function type is passed in, CXCallingConv_Invalid is returned.
  */
-CINDEX_LINKAGE enum CXCallingConv lfort_getFunctionTypeCallingConv(CXType T);
+CINDEX_LINKAGE enum CXCallingConv lfort_getSubprogramTypeCallingConv(CXType T);
 
 /**
  * \brief Retrieve the result type associated with a function type.
@@ -2827,7 +2827,7 @@ CINDEX_LINKAGE CXType lfort_getArgType(CXType T, unsigned i);
 /**
  * \brief Return 1 if the CXType is a variadic function type, and 0 otherwise.
  */
-CINDEX_LINKAGE unsigned lfort_isFunctionTypeVariadic(CXType T);
+CINDEX_LINKAGE unsigned lfort_isSubprogramTypeVariadic(CXType T);
 
 /**
  * \brief Retrieve the result type associated with a given cursor.
@@ -3807,7 +3807,7 @@ CINDEX_LINKAGE CXString lfort_HTMLTagComment_getAsString(CXComment Comment);
  * \li "para-returns" for \\returns paragraph and equivalent commands;
  * \li "word-returns" for the "Returns" word in \\returns paragraph.
  *
- * Function argument documentation is rendered as a \<dl\> list with arguments
+ * Subprogram argument documentation is rendered as a \<dl\> list with arguments
  * sorted in function prototype order.  CSS classes used:
  * \li "param-name-index-NUMBER" for parameter name (\<dt\>);
  * \li "param-descr-index-NUMBER" for parameter description (\<dd\>);
@@ -5090,7 +5090,7 @@ typedef struct {
 typedef enum {
   CXIdxEntity_Unexposed     = 0,
   CXIdxEntity_Typedef       = 1,
-  CXIdxEntity_Function      = 2,
+  CXIdxEntity_Subprogram      = 2,
   CXIdxEntity_Variable      = 3,
   CXIdxEntity_Field         = 4,
   CXIdxEntity_EnumConstant  = 5,
@@ -5116,7 +5116,7 @@ typedef enum {
   CXIdxEntity_CXXInstanceMethod     = 21,
   CXIdxEntity_CXXConstructor        = 22,
   CXIdxEntity_CXXDestructor         = 23,
-  CXIdxEntity_CXXConversionFunction = 24,
+  CXIdxEntity_CXXConversionSubprogram = 24,
   CXIdxEntity_CXXTypeAlias          = 25,
   CXIdxEntity_CXXInterface          = 26
 
@@ -5131,12 +5131,12 @@ typedef enum {
 
 /**
  * \brief Extra C++ template information for an entity. This can apply to:
- * CXIdxEntity_Function
+ * CXIdxEntity_Subprogram
  * CXIdxEntity_CXXClass
  * CXIdxEntity_CXXStaticMethod
  * CXIdxEntity_CXXInstanceMethod
  * CXIdxEntity_CXXConstructor
- * CXIdxEntity_CXXConversionFunction
+ * CXIdxEntity_CXXConversionSubprogram
  * CXIdxEntity_CXXTypeAlias
  */
 typedef enum {
@@ -5451,10 +5451,10 @@ typedef enum {
   CXIndexOpt_SuppressRedundantRefs = 0x1,
 
   /**
-   * \brief Function-local symbols should be indexed. If this is not set
+   * \brief Subprogram-local symbols should be indexed. If this is not set
    * function-local symbols will be ignored.
    */
-  CXIndexOpt_IndexFunctionLocalSymbols = 0x2,
+  CXIndexOpt_IndexSubprogramLocalSymbols = 0x2,
 
   /**
    * \brief Implicit function/class template instantiations should be indexed.

include/lfort/AST/ASTConsumer.h

@@ -26,7 +26,7 @@ namespace lfort {
   class SemaConsumer; // layering violation required for safe SemaConsumer
   class TagDecl;
   class VarDecl;
-  class FunctionDecl;
+  class SubprogramDecl;
   class ImportDecl;
 
 /// ASTConsumer - This is an abstract interface that should be implemented by
@@ -75,7 +75,7 @@ class ASTConsumer {
   /// Note that at this point point it does not have a body, its body is
   /// instantiated at the end of the translation unit and passed to
   /// HandleTopLevelDecl.
-  virtual void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D) {}
+  virtual void HandleCXXImplicitSubprogramInstantiation(SubprogramDecl *D) {}
 
   /// \brief Handle the specified top-level declaration that occurred inside
   /// and ObjC container.
@@ -133,12 +133,12 @@ class ASTConsumer {
   virtual void PrintStats() {}
 
   /// \brief This callback is called for each function if the Parser was
-  /// initialized with \c SkipFunctionBodies set to \c true.
+  /// initialized with \c SkipSubprogramBodies set to \c true.
   ///
   /// \return \c true if the function's body should be skipped. The function
   /// body may be parsed anyway if it is needed (for instance, if it contains
   /// the code completion point or is constexpr).
-  virtual bool shouldSkipFunctionBody(Decl *D) { return true; }
+  virtual bool shouldSkipSubprogramBody(Decl *D) { return true; }
 };
 
 } // end namespace lfort.

include/lfort/AST/ASTContext.h

@@ -106,9 +106,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
   mutable llvm::FoldingSet<DependentSizedExtVectorType>
     DependentSizedExtVectorTypes;
   mutable llvm::FoldingSet<VectorType> VectorTypes;
-  mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
-  mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>
-    FunctionProtoTypes;
+  mutable llvm::FoldingSet<SubprogramNoProtoType> SubprogramNoProtoTypes;
+  mutable llvm::ContextualFoldingSet<SubprogramProtoType, ASTContext&>
+    SubprogramProtoTypes;
   mutable llvm::FoldingSet<DependentTypeOfExprType> DependentTypeOfExprTypes;
   mutable llvm::FoldingSet<DependentDecltypeType> DependentDecltypeTypes;
   mutable llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
@@ -160,7 +160,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   mutable TypeInfoMap MemoizedTypeInfo;
 
   /// \brief A cache mapping from CXXRecordDecls to key functions.
-  llvm::DenseMap<const CXXRecordDecl*, const CXXMethodDecl*> KeyFunctions;
+  llvm::DenseMap<const CXXRecordDecl*, const CXXMethodDecl*> KeySubprograms;
 
   /// \brief Mapping from ObjCContainers to their ObjCImplementations.
   llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;
@@ -174,7 +174,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
 
   /// \brief Mapping from class scope functions specialization to their
   /// template patterns.
-  llvm::DenseMap<const FunctionDecl*, FunctionDecl*>
+  llvm::DenseMap<const SubprogramDecl*, SubprogramDecl*>
     ClassScopeSpecializationPattern;
 
   /// \brief Representation of a "canonical" template template parameter that
@@ -265,7 +265,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   mutable RecordDecl *BlockDescriptorExtendedType;
 
   /// \brief Declaration for the CUDA cudaConfigureCall function.
-  FunctionDecl *cudaConfigureCallDecl;
+  SubprogramDecl *cudaConfigureCallDecl;
 
   TypeSourceInfo NullTypeSourceInfo;
 
@@ -566,10 +566,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
   MemberSpecializationInfo *getInstantiatedFromStaticDataMember(
                                                            const VarDecl *Var);
 
-  FunctionDecl *getClassScopeSpecializationPattern(const FunctionDecl *FD);
+  SubprogramDecl *getClassScopeSpecializationPattern(const SubprogramDecl *FD);
 
-  void setClassScopeSpecializationPattern(FunctionDecl *FD,
-                                          FunctionDecl *Pattern);
+  void setClassScopeSpecializationPattern(SubprogramDecl *FD,
+                                          SubprogramDecl *Pattern);
 
   /// \brief Note that the static data member \p Inst is an instantiation of
   /// the static data member template \p Tmpl of a class template.
@@ -825,8 +825,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
   QualType getConstType(QualType T) const { return T.withConst(); }
 
   /// \brief Change the ExtInfo on a function type.
-  const FunctionType *adjustFunctionType(const FunctionType *Fn,
-                                         FunctionType::ExtInfo EInfo);
+  const SubprogramType *adjustSubprogramType(const SubprogramType *Fn,
+                                         SubprogramType::ExtInfo EInfo);
 
   /// \brief Return the uniqued reference to the type for a complex
   /// number with the specified element type.
@@ -858,10 +858,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// pointer to blocks.
   QualType getBlockDescriptorExtendedType() const;
 
-  void setcudaConfigureCallDecl(FunctionDecl *FD) {
+  void setcudaConfigureCallDecl(SubprogramDecl *FD) {
     cudaConfigureCallDecl = FD;
   }
-  FunctionDecl *getcudaConfigureCallDecl() {
+  SubprogramDecl *getcudaConfigureCallDecl() {
     return cudaConfigureCallDecl;
   }
 
@@ -946,17 +946,17 @@ class ASTContext : public RefCountedBase<ASTContext> {
                                           SourceLocation AttrLoc) const;
 
   /// \brief Return a K&R style C function type like 'int()'.
-  QualType getFunctionNoProtoType(QualType ResultTy,
-                                  const FunctionType::ExtInfo &Info) const;
+  QualType getSubprogramNoProtoType(QualType ResultTy,
+                                  const SubprogramType::ExtInfo &Info) const;
 
-  QualType getFunctionNoProtoType(QualType ResultTy) const {
-    return getFunctionNoProtoType(ResultTy, FunctionType::ExtInfo());
+  QualType getSubprogramNoProtoType(QualType ResultTy) const {
+    return getSubprogramNoProtoType(ResultTy, SubprogramType::ExtInfo());
   }
 
   /// \brief Return a normal function type with a typed argument list.
-  QualType getFunctionType(QualType ResultTy,
+  QualType getSubprogramType(QualType ResultTy,
                            const QualType *Args, unsigned NumArgs,
-                           const FunctionProtoType::ExtProtoInfo &EPI) const;
+                           const SubprogramProtoType::ExtProtoInfo &EPI) const;
 
   /// \brief Return the unique reference to the type for the specified type
   /// declaration.
@@ -1265,7 +1265,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   ///
   /// \returns true if an error occurred (e.g., because one of the parameter
   /// types is incomplete), false otherwise.
-  bool getObjCEncodingForFunctionDecl(const FunctionDecl *Decl, std::string& S);
+  bool getObjCEncodingForSubprogramDecl(const SubprogramDecl *Decl, std::string& S);
 
   /// \brief Emit the encoded type for the method declaration \p Decl into
   /// \p S.
@@ -1569,7 +1569,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   ///
   /// ...the first non-pure virtual function that is not inline at the point
   /// of class definition.
-  const CXXMethodDecl *getKeyFunction(const CXXRecordDecl *RD);
+  const CXXMethodDecl *getKeySubprogram(const CXXRecordDecl *RD);
 
   /// Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
   uint64_t getFieldOffset(const ValueDecl *FD) const;
@@ -1863,12 +1863,12 @@ class ASTContext : public RefCountedBase<ASTContext> {
                                    const ObjCObjectPointerType *RHSOPT);
   bool canBindObjCObjectType(QualType To, QualType From);
 
-  // Functions for calculating composite types
+  // Subprograms for calculating composite types
   QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false,
                       bool Unqualified = false, bool BlockReturnType = false);
-  QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false,
+  QualType mergeSubprogramTypes(QualType, QualType, bool OfBlockPointer=false,
                               bool Unqualified = false);
-  QualType mergeFunctionArgumentTypes(QualType, QualType,
+  QualType mergeSubprogramArgumentTypes(QualType, QualType,
                                       bool OfBlockPointer=false,
                                       bool Unqualified = false);
   QualType mergeTransparentUnionType(QualType, QualType,
@@ -1877,9 +1877,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
 
   QualType mergeObjCGCQualifiers(QualType, QualType);
 
-  bool FunctionTypesMatchOnNSConsumedAttrs(
-         const FunctionProtoType *FromFunctionType,
-         const FunctionProtoType *ToFunctionType);
+  bool SubprogramTypesMatchOnNSConsumedAttrs(
+         const SubprogramProtoType *FromSubprogramType,
+         const SubprogramProtoType *ToSubprogramType);
 
   void ResetObjCLayout(const ObjCContainerDecl *CD) {
     ObjCLayouts[CD] = 0;
@@ -1999,7 +1999,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// when it is called.
   void AddDeallocation(void (*Callback)(void*), void *Data);
 
-  GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD);
+  GVALinkage GetGVALinkageForSubprogram(const SubprogramDecl *FD);
   GVALinkage GetGVALinkageForVariable(const VarDecl *VD);
 
   /// \brief Determines if the decl can be CodeGen'ed or deserialized from PCH