Struct MemberLists 

pub struct MemberLists {

    pub properties: Vec<String>,
    pub fields: Vec<String>,
    pub extension_methods: Vec<(String, String, usize, i64)>,
    pub bases: Vec<String>,
    pub type_params: Vec<String>,
    pub base_generic_args: Vec<(String, Vec<String>)>,
    pub method_returns: OrderedMap<String>,
    pub property_types: OrderedMap<FragFact>,
    pub field_types: OrderedMap<FragFact>,
    pub property_type_files: OrderedMap<String>,
    pub field_type_files: OrderedMap<String>,
    pub method_return_args: OrderedMap<Vec<String>>,
    pub non_public_methods: Vec<String>,
    pub method_arities: OrderedMap<Vec<(usize, i64)>>,
    pub method_params: HashMap<String, Vec<MethodOverloadParams>>,
    pub override_methods: Vec<String>,
}

The non-method halves of a def’s member surface. methods stays on Def (it IS serialized).

Fields

properties: Vec<String>

The properties value.

fields: Vec<String>

The fields value.

extension_methods: Vec<(String, String, usize, i64)>

Kept here for the same reason as properties/fields: a resolution input, never a serialized def field. Holds the (name, this_type, arity_min, arity_max) QUADRUPLES this def has already contributed, so a partial class re-declaring one of its own entries in a second file can never push the def into its own extension bucket twice and make itself look like two candidates.

bases: Vec<String>

DIRECT base-type names, unioned across a partial class’s declarations, resolved LAZILY by the veto walk.

type_params: Vec<String>

The declaring type’s own type-parameter names (empty for a non-generic declaration). A resolution input, like bases: the ctor-DI resolver’s “is this def itself an open-generic implementation” signal. First declaration wins, like namespace/kind – not unioned across a partial class the way bases is.

base_generic_args: Vec<(String, Vec<String>)>

Per base name that carried a type-argument list, that list’s generic-arg descriptors relative to type_params. First declaration wins, same as type_params.

method_returns: OrderedMap<String>

Method name -> declared return type NAME, the fact that turns a var x = Q.M(...) local into an ordinary receiver. A partial class’s later parts contribute the names the first part did not answer; a name it already answered keeps its answer.

property_types: OrderedMap<FragFact>

Property name -> declared type fact, the second half of a property hop. Merged across a partial class exactly like method_returns.

field_types: OrderedMap<FragFact>

Field name -> declared type fact, the field half of a bare-identifier receiver’s type when the file that reads it carries no local/ parameter/field fact of its own for the name (a sibling partial-class file’s field, reached only through this merged table). Merged across a partial class exactly like property_types.

property_type_files: OrderedMap<String>

The file whose declaration supplied each property_types / field_types entry – one key per key of the table beside it, filled in at merge time. Purely an in-memory bookkeeping table (nothing here is serialized), and the only record of WHERE a merged fact came from: a partial class’s def carries the FIRST declaring file, which is not necessarily the file that declared any given member. The type name a fact holds is a bare identifier that only means anything under the using directives, aliases and namespace of the file that WROTE it, so bare_receiver_field_or_property_type’s caller resolves it in that file’s context rather than the reading file’s.

field_type_files: OrderedMap<String>

The field_types half of property_type_files.

method_return_args: OrderedMap<Vec<String>>

Method name -> the generic-arg descriptors method_returns itself strips off (see FragDef.method_return_args), read ONLY by the awaited-call unwrap: an entry here exists exactly when the same name has a method_returns entry AND that return type carried a top-level type-argument list. Merged across a partial class exactly like method_returns.

non_public_methods: Vec<String>

Declared method names methods (on Def) does not carry – see FragDef.non_public_methods. Merged across a partial class exactly like properties/fields (union, first-insertion order). Read ONLY by declares_member_any_visibility, itself read ONLY for hierarchy-internal receivers (base. and the this. shape’s own base walk); every other caller of a “does this def declare the member” question keeps reading Def.methods alone.

method_arities: OrderedMap<Vec<(usize, i64)>>

Method name -> the (min, max) argument-count ranges the overloads sharing that name accept – see FragDef.method_arities. Merged across a partial class as a UNION of ranges per NAME, the way Def.methods unions the names themselves: every declaring part contributes the overloads it declares, duplicates dropped, because the parts of one partial class share a single overload set and a call some part’s overload accepts is a call the type accepts. Read by declares_member/declares_member_any_visibility for a ref that carries an argCount.

method_params: HashMap<String, Vec<MethodOverloadParams>>

Method name -> the overloads’ own parameter-descriptor lists, each paired with the file whose fragment declared it – see FragDef.method_params. Merged across a partial class as a UNION per NAME, the way method_arities is: every declaring part contributes the overloads it declares, an overload whose params list already exists for that name skipped (first file wins for duplicates). In memory only; nothing here is serialized.

override_methods: Vec<String>

Declared method names carrying the literal override modifier – see FragDef.override_methods. Merged across a partial class exactly like non_public_methods: union, first-insertion order. Read ONLY by the resolver’s member-level overrides pass, itself run only for a type already known to be a registered DI implementation.

Trait Implementations

impl Default for MemberLists

fn default() -> Self

Returns the “default value” for a type.