SymbolFlags

Symbols have SymbolFlags. Below we have them in their verbatim, as of TypeScript 2.2

  1.     export const enum SymbolFlags {
  2.         None                    = 0,
  3.         FunctionScopedVariable  = 1 << 0,   // Variable (var) or parameter
  4.         BlockScopedVariable     = 1 << 1,   // A block-scoped variable (let or const)
  5.         Property                = 1 << 2,   // Property or enum member
  6.         EnumMember              = 1 << 3,   // Enum member
  7.         Function                = 1 << 4,   // Function
  8.         Class                   = 1 << 5,   // Class
  9.         Interface               = 1 << 6,   // Interface
  10.         ConstEnum               = 1 << 7,   // Const enum
  11.         RegularEnum             = 1 << 8,   // Enum
  12.         ValueModule             = 1 << 9,   // Instantiated module
  13.         NamespaceModule         = 1 << 10,  // Uninstantiated module
  14.         TypeLiteral             = 1 << 11,  // Type Literal or mapped type
  15.         ObjectLiteral           = 1 << 12,  // Object Literal
  16.         Method                  = 1 << 13,  // Method
  17.         Constructor             = 1 << 14,  // Constructor
  18.         GetAccessor             = 1 << 15,  // Get accessor
  19.         SetAccessor             = 1 << 16,  // Set accessor
  20.         Signature               = 1 << 17,  // Call, construct, or index signature
  21.         TypeParameter           = 1 << 18,  // Type parameter
  22.         TypeAlias               = 1 << 19,  // Type alias
  23.         ExportValue             = 1 << 20,  // Exported value marker (see comment in declareModuleMember in binder)
  24.         ExportType              = 1 << 21,  // Exported type marker (see comment in declareModuleMember in binder)
  25.         ExportNamespace         = 1 << 22,  // Exported namespace marker (see comment in declareModuleMember in binder)
  26.         Alias                   = 1 << 23,  // An alias for another symbol (see comment in isAliasSymbolDeclaration in checker)
  27.         Prototype               = 1 << 24,  // Prototype property (no source representation)
  28.         ExportStar              = 1 << 25,  // Export * declaration
  29.         Optional                = 1 << 26,  // Optional property
  30.         Transient               = 1 << 27,  // Transient symbol (created during type check)
  32.         Enum = RegularEnum | ConstEnum,
  33.         Variable = FunctionScopedVariable | BlockScopedVariable,
  34.         Value = Variable | Property | EnumMember | Function | Class | Enum | ValueModule | Method | GetAccessor | SetAccessor,
  35.         Type = Class | Interface | Enum | EnumMember | TypeLiteral | ObjectLiteral | TypeParameter | TypeAlias,
  36.         Namespace = ValueModule | NamespaceModule | Enum,
  37.         Module = ValueModule | NamespaceModule,
  38.         Accessor = GetAccessor | SetAccessor,
  40.         // Variables can be redeclared, but can not redeclare a block-scoped declaration with the
  41.         // same name, or any other value that is not a variable, e.g. ValueModule or Class
  42.         FunctionScopedVariableExcludes = Value & ~FunctionScopedVariable,
  44.         // Block-scoped declarations are not allowed to be re-declared
  45.         // they can not merge with anything in the value space
  46.         BlockScopedVariableExcludes = Value,
  48.         ParameterExcludes = Value,
  49.         PropertyExcludes = None,
  50.         EnumMemberExcludes = Value | Type,
  51.         FunctionExcludes = Value & ~(Function | ValueModule),
  52.         ClassExcludes = (Value | Type) & ~(ValueModule | Interface), // class-interface mergability done in checker.ts
  53.         InterfaceExcludes = Type & ~(Interface | Class),
  54.         RegularEnumExcludes = (Value | Type) & ~(RegularEnum | ValueModule), // regular enums merge only with regular enums and modules
  55.         ConstEnumExcludes = (Value | Type) & ~ConstEnum, // const enums merge only with const enums
  56.         ValueModuleExcludes = Value & ~(Function | Class | RegularEnum | ValueModule),
  57.         NamespaceModuleExcludes = 0,
  58.         MethodExcludes = Value & ~Method,
  59.         GetAccessorExcludes = Value & ~SetAccessor,
  60.         SetAccessorExcludes = Value & ~GetAccessor,
  61.         TypeParameterExcludes = Type & ~TypeParameter,
  62.         TypeAliasExcludes = Type,
  63.         AliasExcludes = Alias,
  65.         ModuleMember = Variable | Function | Class | Interface | Enum | Module | TypeAlias | Alias,
  67.         ExportHasLocal = Function | Class | Enum | ValueModule,
  69.         HasExports = Class | Enum | Module,
  70.         HasMembers = Class | Interface | TypeLiteral | ObjectLiteral,
  72.         BlockScoped = BlockScopedVariable | Class | Enum,
  74.         PropertyOrAccessor = Property | Accessor,
  75.         Export = ExportNamespace | ExportType | ExportValue,
  77.         ClassMember = Method | Accessor | Property,
  79.         /* @internal */
  80.         // The set of things we consider semantically classifiable.  Used to speed up the LS during
  81.         // classification.
  82.         Classifiable = Class | Enum | TypeAlias | Interface | TypeParameter | Module,
  83.     }

ValueModule

ValueModule // Instantiated module is the SymbolFlag used for SourceFile if it an external module.