This document describes the AST representation of static constants, static variables, and static methods/functions in XGo, covering both normal XGo files and classfiles.

XGo introduces static members — static constants, static variables, and static methods — as type-scoped declarations. The AST must distinguish these from global declarations and instance members. Two existing node types carry this information:

• FuncDecl — for functions and methods (static or not)
• ValueSpec — for const and var declarations (static or not)

type FuncDecl struct {
    Doc      *CommentGroup // associated documentation; or nil
    Recv     *FieldList    // receiver (methods); or nil (functions)
    Name     *Ident        // function/method name
    Type     *FuncType     // function signature: parameters, results, and position of "func" keyword
    Body     *BlockStmt    // function body; or nil for external (non-Go) function
    Operator bool          // is operator or not
    Shadow   bool          // is a shadow entry
    IsClass  bool          // recv set by class
    Static   bool          // recv is static (class method)
}

• Static bool: set to true when the declaration is a static method (either T.Method or .Method form).
• Recv *FieldList: carries the receiver type T for the T.Method form; non-nil but with len(Recv.List) == 0 for the .Method shorthand form in classfiles.
• Name *Ident: always holds the bare method name (without the T. or . prefix).

• For normal XGo, a bare func name(...) is a global function: Static=false, Recv=nil.
• For classfiles, a bare func name(...) is an instance method: Static=false, Recv is non-nil and set by the class mechanism (IsClass=true).
• func T.Method(...) is unambiguously a static method in both contexts. Recv holds T as a regular field entry.
• func .Method(...) is the classfile shorthand for a static method on the owning class. Recv is non-nil but len(Recv.List) == 0, indicating "static on the implicit class type."

type ValueSpec struct {
    Doc       *CommentGroup // associated documentation; or nil
    Names     []*Ident      // value names (len >= 1)
    Type      Expr          // value type; or nil
    Tag       *BasicLit     // classfile field tag; or nil
    Values    []Expr        // initial values; or nil
    Comment   *CommentGroup // line comments; or nil
    HasStatic bool          // true if any name is in ".name" or "T.name" form
}

• HasStatic bool: set to true when at least one name in Names uses the T.name or .name static form. When false, all names are bare identifiers (global or instance members).
• Names []*Ident: each Ident in the slice carries its parsed name. For a static name in T.name form the identifier encodes the qualifier; for .name form the identifier encodes the shorthand.

Note: A single ValueSpec may mix static and non-static names (e.g., const T.A, B = 1, 2). HasStatic signals that at least one name requires special handling; consumers must inspect each Ident individually to determine which names are static.

† In classfiles, bare var name declares a class (instance) member. At most one top-level var block with bare names is permitted per classfile; a second such block is a compile-time error.

When walking the AST, consumers can classify any declaration using the following rules:

if Static == false && Recv == nil         → global function (normal XGo)
if Static == false && Recv != nil         → instance method (classfile, IsClass=true)
if Static == true  && len(Recv.List) > 0  → static method with explicit type T
if Static == true  && len(Recv.List) == 0 → static method via classfile shorthand (.Method)

if HasStatic == false → all names are global constants (both contexts)
if HasStatic == true  → at least one name is a static constant;
                        inspect each Ident for "T.name" or ".name" form

if HasStatic == false, in normal XGo  → all names are global variables
if HasStatic == false, in classfile   → all names are class (instance) members
if HasStatic == true                  → at least one name is a static variable;
                                        inspect each Ident for "T.name" or ".name" form

• Classfile var block limit: A classfile may contain at most one top-level var block whose names are bare (non-static) identifiers. Parsing a second such block is a compile-time error.
• type declarations: type declarations are always global in both contexts. There is no T.Name or .Name syntax for types, and no static flag is needed on type nodes.
• Mixed ValueSpec: A single ValueSpec may contain both static and non-static names. HasStatic=true does not imply that all names are static — only that at least one is. Semantic analysis must inspect individual Ident nodes.