SageBuilder::function_declaration_ownership
Exact, typed structural ownership established by function‐declaration builders. Invalid kind/owner combinations cannot be constructed.
Synopsis
Declared in <SageIII/sageInterface/sageBuilder.h>
class function_declaration_ownership;Enums
Name |
Description |
Special‐member identity that must be known before a member declaration's structural initializer‐list child is source‐classified. |
Member Functions
Name |
Description |
Return the exact symbol‐table key for this construction transaction. |
|
Retarget an in‐progress redeclaration or canonical‐replacement transaction after re‐entrant construction has re‐rooted the same exact function family. All other typed construction properties are preserved. The replacement must be the family's self‐canonical declaration. |
|
Preserve a source function declarator whose complete type comes from a typeof specifier and therefore owns semantic parameters but no written parameter‐list child. This is a construction contract, not an unparser recovery mode. |
|
Add exact special‐member identity to a function construction transaction. This is valid only for member‐function builders and cannot be changed once present. |
|
Make a translated template‐head requires‐clause part of a function template's overload identity before its declaration and symbol are constructed. The expression must be detached and is transferred to the newly constructed template function declaration. |
|
Make a translated trailing requires‐clause part of the function overload identity before any declaration or symbol is constructed. The expression must be detached; the builder transfers its ownership to the declaration it constructs. |
|
Retain a semantically rejected template instantiation in the auxiliary AST while prohibiting construction of a lookup symbol. The builder validates that this contract is used only for semantic template instantiations; it never publishes and then removes a symbol. |
Static Member Functions
Name |
Description |
Publish a distinct semantic declaration while atomically re‐rooting an already published semantic declaration family and its one direct symbol. The replacement target must be exactly auxiliary‐owned in the same semantic scope. |
|
Publish through semantic auxiliary ownership while leaving the complete function declaration subtree unclassified for one exact frontend source publication. This transaction is valid only in frontend‐construction mode and must not be used for defining declarations. |
|
Publish a distinct semantic declaration in the exact auxiliary owner of an already published function family. The target remains canonical and its direct symbol is reused without name/type lookup. |
|
Publish a source declaration‐group member while joining an already published exact function family. The group remains the structural owner and the target supplies the canonical declaration/symbol identity. |
|
Publish a generated declaration at the beginning of an exact lexical owner and make it the canonical declaration/symbol basis of an existing declaration family. |
|
Publish a generated declaration immediately before an exact source anchor and make it the canonical declaration/symbol basis of an existing declaration family. The target remains in its original lexical owner. |
|
Publish a source declaration in its exact lexical owner while replacing a later source redeclaration that was necessarily constructed first by a re‐entrant frontend translation. The replacement target remains in its own lexical source position; only the canonical declaration/symbol basis is re‐rooted to the earlier source declaration. |
|
Construct a frontend source declaration with its exact semantic scope, but keep it physically detached until the frontend has published the immutable source range and translation‐unit order. This transaction is valid only in frontend‐construction mode. |
|
Construct a distinct source redeclaration in its exact lexical owner, join an already published canonical function family, and leave the declaration subtree unclassified until the frontend publishes its exact source ranges. This is the source/redeclaration transaction for a declaration whose lexical and semantic owners differ, such as a qualified friend member declaration. |
|
Construct one dependent friend template‐id source surface in its exact class lexical owner and namespace semantic scope. Clang has not selected a concrete specialization declaration in this state, so the node carries its typed primary‐template identity and deliberately publishes no independent function symbol or redeclaration‐chain edge. |
|
Publish a distinct source declaration in its exact lexical owner while joining an already published canonical function family. The target remains the canonical declaration and its one direct symbol is reused; no name/type lookup is permitted to select another overload family. |
|
Private Member Functions
Name |
|
Private Data Members
Name |
Non-Member Functions
Name |
Description |
Build a function declaration with a function body |
|
Build a defining ( non‐prototype) member function declaration |
|
Build a prototype for an existing function declaration (defining or nondefining is fine) |
|
Build a prototype for a function, handle function type, symbol etc transparently |
|
Build a prototype member function declaration |
|
Build a nondefining SgProcedureHeaderStatement, handle function type, symbol etc transparently |
|
Build a defining Fortran procedure with an explicit lexical source form. |
|
Complete a bottom‐up Fortran procedure construction around its exact preconstructed definition and body. The definition is consumed exactly once and must already carry final source classification and scope identity. |
Created with MrDocs