Source

String linkedParams(
    {bool showMetadata: true, bool showNames: true, String separator: ', '}) {
  String renderParam(Parameter param, String suffix) {
    StringBuffer buf = new StringBuffer();
    buf.write('<span class="parameter" id="${param.htmlId}">');
    if (showMetadata && param.hasAnnotations) {
      param.annotations.forEach((String annotation) {
        buf.write('<span>$annotation</span> ');
      });
    }
    if (param.modelType.isFunctionType) {
      var returnTypeName;
      bool isTypedef = param.modelType.element is Typedef;
      if (isTypedef) {
        returnTypeName = param.modelType.linkedName;
      } else {
        returnTypeName = param.modelType.createLinkedReturnTypeName();
      }
      buf.write('<span class="type-annotation">${returnTypeName}</span>');
      if (showNames) {
        buf.write(' <span class="parameter-name">${param.name}</span>');
      }
      if (!isTypedef) {
        buf.write('(');
        buf.write(param.modelType.element
            .linkedParams(showNames: showNames, showMetadata: showMetadata));
        buf.write(')');
      }
    } else if (param.modelType != null && param.modelType.element != null) {
      var mt = param.modelType;
      String typeName = "";
      if (mt != null && !mt.isDynamic) {
        typeName = mt.linkedName;
      }
      if (typeName.isNotEmpty) {
        buf.write('<span class="type-annotation">$typeName</span>');
      }
      if (typeName.isNotEmpty && showNames && param.name.isNotEmpty)
        buf.write(' ');
      if (showNames && param.name.isNotEmpty) {
        buf.write('<span class="parameter-name">${param.name}</span>');
      }
    }

    if (param.hasDefaultValue) {
      if (param.isOptionalNamed) {
        buf.write(': ');
      } else {
        buf.write(' = ');
      }
      buf.write('<span class="default-value">${param.defaultValue}</span>');
    }
    buf.write('${suffix}</span>');
    return buf.toString();
  }

  List<Parameter> requiredParams =
      parameters.where((Parameter p) => !p.isOptional).toList();
  List<Parameter> positionalParams =
      parameters.where((Parameter p) => p.isOptionalPositional).toList();
  List<Parameter> namedParams =
      parameters.where((Parameter p) => p.isOptionalNamed).toList();

  StringBuffer builder = new StringBuffer();

  // prefix
  if (requiredParams.isEmpty && positionalParams.isNotEmpty) {
    builder.write('[');
  } else if (requiredParams.isEmpty && namedParams.isNotEmpty) {
    builder.write('{');
  }

  // index over params
  for (Parameter param in requiredParams) {
    bool isLast = param == requiredParams.last;
    String ext;
    if (isLast && positionalParams.isNotEmpty) {
      ext = ', [';
    } else if (isLast && namedParams.isNotEmpty) {
      ext = ', {';
    } else {
      ext = isLast ? '' : ', ';
    }
    builder.write(renderParam(param, ext));
    builder.write(' ');
  }
  for (Parameter param in positionalParams) {
    bool isLast = param == positionalParams.last;
    builder.write(renderParam(param, isLast ? '' : ', '));
    builder.write(' ');
  }
  for (Parameter param in namedParams) {
    bool isLast = param == namedParams.last;
    builder.write(renderParam(param, isLast ? '' : ', '));
    builder.write(' ');
  }

  // suffix
  if (namedParams.isNotEmpty) {
    builder.write('}');
  } else if (positionalParams.isNotEmpty) {
    builder.write(']');
  }

  return builder.toString().trim();
}