resolveTypeItem()

in src/resolver/base.js [138:255]

• 116 lines of code
• 51 McCabe index (conditional complexity)

  resolveTypeItem(typeNode, sourceNode = null, prop) {
    if (typeNode.idType) {
      if (typeNode.idType === 'model') {
        return new TypeObject(`#${typeNode.lexeme}`);
      } else if (typeNode.idType === 'module') {
        return new TypeObject(`^${typeNode.lexeme}`);
      } else if (typeNode.idType === 'builtin_model') {
        return new TypeObject(`^${typeNode.lexeme}`);
      }
      debug.stack(typeNode, sourceNode);
    } else if (typeNode.type) {
      if (typeNode.type === 'fieldType') {
        if (typeNode.fieldType.idType) {
          if (typeNode.fieldType.idType === 'module') {
            return new TypeObject(`^${typeNode.fieldType.lexeme}`);
          }
          return new TypeObject(`#${typeNode.fieldType.lexeme}`);
        }
        return this.resolveTypeItem(typeNode.fieldType, typeNode, prop);
      } else if (typeNode.type === 'modelBody') {
        // is sub model
        const modelName = `#${[this.object.name, _escape(sourceNode.fieldName.lexeme) || _string(sourceNode.fieldName)].join('.')}`;
        return new TypeObject(modelName);
      } else if (_isBasicType(typeNode.type)) {
        return this.resolveTypeItem(typeNode.type, typeNode);
      } else if (typeNode.type === 'basic') {
        return this.resolveTypeItem(typeNode.name || 'null', sourceNode);
      } else if (typeNode.type === 'model') {
        let name = typeNode.name;
        if (typeNode.moduleName) {
          name = typeNode.moduleName + '.' + name;
        }
        return new TypeObject(`#${name}`);
      } else if (typeNode.type === 'module_instance') {
        return new TypeObject(`^${typeNode.name}`);
      } else if (typeNode.type === 'param') {
        if (typeNode.paramType.idType) {
          return new TypeObject(`#${typeNode.paramType.lexeme}`);
        }
        return this.resolveTypeItem(typeNode.paramType, typeNode);
      } else if (typeNode.type === 'array') {
        const subType = typeNode.subType ? typeNode.subType : typeNode.itemType;
        return new TypeArray(this.resolveTypeItem(subType));
      } else if (typeNode.type === 'moduleModel') {
        let tmp = [];
        typeNode.path.forEach(item => {
          tmp.push(item.lexeme);
        });
        return new TypeObject(`#${tmp.join('.')}`);
      } else if (typeNode.type === 'subModel' || typeNode.type === 'subModel_or_moduleModel') {
        // subModel_or_moduleModel is retained for compatibility with older parser.
        let tmp = [];
        typeNode.path.forEach(item => {
          tmp.push(item.lexeme);
        });
        return new TypeObject(`#${tmp.join('.')}`);
      }
      debug.stack(typeNode, sourceNode);
    } else if (typeNode.lexeme) {
      return this.resolveTypeItem(typeNode.lexeme, sourceNode);
    } else if (typeNode === 'string') {
      return new TypeString();
    } else if (typeNode === 'bytes') {
      return new TypeBytes();
    } else if (typeNode === 'array') {
      let itemType;
      if (sourceNode.fieldItemType.type === 'modelBody') {
        itemType = new TypeObject(`#${sourceNode.itemType ? sourceNode.itemType : prop}`);
      } else if (sourceNode.fieldItemType.idType === 'model') {
        itemType = new TypeObject(`#${sourceNode.fieldItemType.lexeme}`);
      } else {
        itemType = this.resolveTypeItem(sourceNode.fieldItemType, sourceNode, sourceNode.itemType ? sourceNode.itemType : prop);
      }
      return new TypeArray(itemType);
    } else if (typeNode === 'map') {
      const keyType = this.resolveTypeItem(sourceNode.keyType);
      const valType = this.resolveTypeItem(sourceNode.valueType);
      return new TypeMap(keyType, valType);
    } else if (typeNode === 'any') {
      return new TypeGeneric();
    } else if (typeNode === 'object') {
      return new TypeMap(new TypeString(), new TypeGeneric());
    } else if (typeNode === 'integer') {
      return new TypeInteger();
    } else if (typeNode === 'readable') {
      return new TypeInputStream();
    } else if (typeNode === 'writable') {
      return new TypeOutputStream();
    } else if (typeNode === 'class') {
      return new TypeObject();
    } else if (typeNode === 'void') {
      return new TypeVoid();
    } else if (typeNode === 'number') {
      return new TypeNumber();
    } else if (typeNode === 'boolean') {
      return new TypeBool();
    } else if (typeNode === 'null') {
      return new TypeNull();
    } else if (typeNode === 'float') {
      return new TypeDecimal(4);
    } else if (typeNode === 'double') {
      return new TypeDecimal(8);
    } else if (typeNode === 'long') {
      return new TypeInteger(64);
    } else if (typeNode === 'ulong') {
      return new TypeInteger(64, true);
    } else if (typeNode.indexOf('int') === 0) {
      let len = typeNode.substring(3);
      return new TypeInteger(parseInt(len));
    } else if (typeNode.indexOf('uint') === 0) {
      let len = typeNode.substring(4);
      return new TypeInteger(parseInt(len), true);
    }
    if (typeof typeNode === 'string' && typeNode.length > 0) {
      return new TypeObject(`#${typeNode}`);
    }
    debug.stack('Unsupported type node', { typeNode, sourceNode });
  }