TreeSitterLanguageTable.fromJson constructor

TreeSitterLanguageTable.fromJson(Map<String, Object?> json)

Implementation

factory TreeSitterLanguageTable.fromJson(Map<String, Object?> json) {
  final names = _strings(json, 'SymbolNames');
  final metadata = _maps(json, 'SymbolMetadata');
  if (names.length != metadata.length) {
    throw const FormatException('Symbol name/metadata count mismatch');
  }
  final lexStateJson = _maps(json, 'LexStates');
  final keywordLexStateJson = _maps(json, 'KeywordLexStates');
  final lexAcceptsEnd = _optionalBools(
    json,
    'LexAcceptsEnd',
    lexStateJson.length,
  );
  final keywordLexAcceptsEnd = _optionalBools(
    json,
    'KeywordLexAcceptsEnd',
    keywordLexStateJson.length,
  );
  final result = TreeSitterLanguageTable(
    name: _string(json, 'Name'),
    languageVersion: _int(json, 'LanguageVersion'),
    metadata: switch (json['Metadata']) {
      final Map value => TreeSitterLanguageMetadata.fromJson(
        value.cast<String, Object?>(),
      ),
      _ => null,
    },
    symbolCount: _int(json, 'SymbolCount'),
    tokenCount: _int(json, 'TokenCount'),
    externalTokenCount: _int(json, 'ExternalTokenCount'),
    stateCount: _int(json, 'StateCount'),
    largeStateCount: _int(json, 'LargeStateCount'),
    fieldCount: _int(json, 'FieldCount'),
    productionIdCount: _int(json, 'ProductionIDCount'),
    symbols: [
      for (var index = 0; index < names.length; index++)
        TreeSitterSymbolMetadata.fromJson(names[index], metadata[index]),
    ],
    publicSymbolMap: _ints(json, 'PublicSymbolMap'),
    fieldNames: _strings(json, 'FieldNames'),
    fieldMapSlices: ((json['FieldMapSlices'] as List?) ?? const [])
        .map(TreeSitterFieldMapSlice.fromJson)
        .toList(growable: false),
    fieldMapEntries: _maps(
      json,
      'FieldMapEntries',
    ).map(TreeSitterFieldMapEntry.fromJson).toList(growable: false),
    aliasSequences: _intRows(json, 'AliasSequences'),
    nonTerminalAliasMap: _nullableIntRows(json, 'NonTerminalAliasMap'),
    parseTable: _intRows(json, 'ParseTable'),
    smallParseTable: _ints(json, 'SmallParseTable'),
    smallParseTableMap: _ints(json, 'SmallParseTableMap'),
    parseActions: _maps(
      json,
      'ParseActions',
    ).map(TreeSitterParseActionEntry.fromJson).toList(growable: false),
    lexModes: _maps(
      json,
      'LexModes',
    ).map(TreeSitterLexMode.fromJson).toList(growable: false),
    reservedWords: _ints(json, 'ReservedWords'),
    maxReservedWordSetSize:
        (json['MaxReservedWordSetSize'] as num?)?.toInt() ?? 0,
    lexStates: [
      for (var index = 0; index < lexStateJson.length; index++)
        TreeSitterLexState.fromJson(
          lexStateJson[index],
          acceptsEnd: lexAcceptsEnd[index],
        ),
    ],
    keywordLexStates: [
      for (var index = 0; index < keywordLexStateJson.length; index++)
        TreeSitterLexState.fromJson(
          keywordLexStateJson[index],
          acceptsEnd: keywordLexAcceptsEnd[index],
        ),
    ],
    keywordCaptureToken: _int(json, 'KeywordCaptureToken'),
    externalSymbols: _ints(json, 'ExternalSymbols'),
    externalLexStates: _boolRows(json, 'ExternalLexStates'),
    initialState: _int(json, 'InitialState'),
    primaryStateIds: _ints(json, 'PrimaryStateIDs'),
    supertypeSymbols: _ints(json, 'SupertypeSymbols'),
    supertypeMapSlices: ((json['SupertypeMapSlices'] as List?) ?? const [])
        .map(TreeSitterFieldMapSlice.fromJson)
        .toList(growable: false),
    supertypeMapEntries: _ints(json, 'SupertypeMapEntries'),
    queryNodeTypes: ((json['QueryNodeTypes'] as List?) ?? const [])
        .cast<Map>()
        .map(
          (value) =>
              TreeSitterQueryNodeType.fromJson(value.cast<String, Object?>()),
        )
        .toList(growable: false),
  );
  result.validate();
  return result;
}