getParameterType()

in lib/semantic.js [1481:1579]

• 79 lines of code
• 28 McCabe index (conditional complexity)

  getParameterType(type, moduleName) {

    if (type.tag === Tag.TYPE && type.lexeme === 'object') {
      return {
        type: 'map',
        keyType: _basic('string'),
        valueType: _basic('any')
      };
    } else if (type.type === 'map') {
      return {
        type: 'map',
        keyType: _basic('string'),
        valueType: this.getParameterType(type.valueType, moduleName)
      };
    } else if (type.type === 'iterator' || type.type === 'asyncIterator') {
      return {
        type: type.type,
        valueType: this.getParameterType(type.valueType, moduleName)
      };
    } else if (type.tag === Tag.TYPE) {
      return _basic(type.lexeme);
    } else if (type.tag === Tag.ID && builtin.has(type.lexeme)) {
      const ast = builtin.get(type.lexeme);
      if(ast.type === 'model') {
        return _model(type.lexeme);
      }
      return {
        type: 'module_instance',
        name: type.lexeme
      };
      
    } else if (type.tag === Tag.ID && type.lexeme.startsWith('$')) {
      return _model(type.lexeme);
    } else if (type.tag === Tag.ID && type.idType === 'model') {
      const checker = moduleName ? this.dependencies.get(moduleName) : this;
      return checker.getModel(type.lexeme, moduleName);
    } else if (type.tag === Tag.ID && this.dependencies.has(type.lexeme)) {
      return {
        type: 'module_instance',
        name: type.lexeme
      };
    } else if (type.tag === Tag.ID && type.idType === 'typedef') {
      return _typedef(type.lexeme, moduleName);
    } else if (type.tag === Tag.ID) {
      return this.getModel(type.lexeme);
    } else if (
      type.type === 'moduleModel' ||
      type.type === 'subModel' || 
      type.type === 'subModel_or_moduleModel') {
      if (moduleName && type.type === 'subModel') {
        const checker = this.dependencies.get(moduleName);
        return checker.getModel(type.path.map((item) => {
          return item.lexeme;
        }).join('.'), moduleName);
      }
      const [mainId, ...rest] = type.path;
      const idType = this.getIdType(mainId.lexeme);
      if (idType === 'module') {
        const checker = this.dependencies.get(mainId.lexeme);
        const typeName = rest.map((item) => {
          return item.lexeme;
        }).join('.');
        if (checker.models.has(typeName)) {
          return checker.getModel(rest.map((item) => {
            return item.lexeme;
          }).join('.'), mainId.lexeme);
        } else if (checker.enums.has(typeName)) {
          return _enum(rest.map((item) => {
            return item.lexeme;
          }).join('.'), mainId.lexeme);
        } else if (checker.typedefs.has(typeName)) {
          return _typedef(rest.map((item) => {
            return item.lexeme;
          }).join('.'), mainId.lexeme);
        }
        
      }

      if (idType === 'model') {
        return this.getModel(type.path.map((item) => {
          return item.lexeme;
        }).join('.'));
      }
      
    } else if (type.type === 'moduleTypedef') {
      const [mainId, ...rest] = type.path;
      return _typedef(rest.map((item) => {
        return item.lexeme;
      }).join('.'), mainId.lexeme);
    } else if (type.type === 'array') {
      return {
        type: 'array',
        itemType: this.getParameterType(type.subType, moduleName)
      };
    }

    console.log(type);
    throw new Error('un-implemented');
  }