constructLookupTypeDef method

Implementation

List<LookupTypeDef> constructLookupTypeDef(
    Map<int, LookupValue> definitions, Map<int, int> accessibleTypes, int frameId) {
  final def = definitions[frameId]!.def;

  switch (def.tag) {
    case 'composite':
      return [
        LookupTypeDef(
          tag: def.tag,
          value: LookupTypeDefComposite(
            fields: def.value
                .map<LookupField>(
                  (f) => LookupField(
                    name: f.name,
                    typeName: f.typeName,
                    ty: getTypeRef(definitions, accessibleTypes, f.type),
                  ),
                )
                .toList(),
          ),
        )
      ];
    case 'variant':
      return def.value
          .map<LookupTypeDef>(
            (v) => LookupTypeDef(
              tag: 'enumeration',
              value: LookupTypeDefEnumeration(
                name: v.name,
                index: v.index,
                fields: v.fields
                    .map<LookupField>(
                      (field) => LookupField(
                        name: field.name,
                        typeName: field.typeName,
                        ty: getTypeRef(definitions, accessibleTypes, field.type),
                      ),
                    )
                    .toList(),
              ),
            ),
          )
          .toList();
    case 'sequence':
      return [
        LookupTypeDef(
          tag: def.tag,
          value: getTypeRef(definitions, accessibleTypes, def.value),
        ),
      ];
    case 'array':
      return [
        LookupTypeDef(
          tag: def.tag,
          value: LookupTypeDefArray(
            len: def.value.len,
            typeParam: getTypeRef(definitions, accessibleTypes, def.value.type),
          ),
        ),
      ];
    case 'tuple':
      return [
        LookupTypeDef(
          tag: def.tag,
          value:
              def.value.map<TypeRef>((t) => getTypeRef(definitions, accessibleTypes, t)).toList(),
        ),
      ];
    case 'bitSequence':
      final primitive = getPrimitive(definitions, def.value.bitStoreType);
      final numBytes = getBitSequenceBytes(primitive);

      final storeOrderPath = definitions[def.value.bitOrderType]!.path;
      final leastSignificantBitFirst = storeOrderPath.contains('Lsb0');
      if (!leastSignificantBitFirst && !storeOrderPath.contains('Msb0')) {
        throw Exception('Invalid bit order type');
      }

      return [
        LookupTypeDef(
          tag: 'bitSequence',
          value: LookupTypeDefBitSequence(
            numBytes: numBytes,
            leastSignificantBitFirst: leastSignificantBitFirst,
          ),
        )
      ];
  }

  throw Exception('FrameId($frameId) should have been filtered out');
}