Create a DiagnosticType at level CheckLevel.ERROR

@param name An identifier
@param descriptionFormat A format string
@return A new DiagnosticType
351023
public static DiagnosticType error(String name, String descriptionFormat) {
    return make(name, CheckLevel.ERROR, descriptionFormat);
  }
890566
public String getFormAttribute(@NotNull final String name, String defaultValue) {
        String value = request.formAttributes().get(name);

        if (value == null) {
            return defaultValue;
        }

        return value;
    }
433770
public final <T> void addOption(String name, String description)
    {
        addOption(String.class, name, description, null);
    }
797264
public ISarlEventBuilder addSarlEvent(String name) {
		ISarlEventBuilder builder = this.sarlEventProvider.get();
		builder.eInit(getScript(), name, getTypeResolutionContext());
		return builder;
	}
280296
protected function addFormatter(ServiceContainer $container, $name, $class)
    {
        $container->set(
          'formatter.formatters.' . $name,
          function (ServiceContainer $c) use ($class) {
              $c->set('formatter.presenter', new StringPresenter($c->get('formatter.presenter.differ')));

              /** @var ServiceContainer $c */
              return new $class(
                $c->get('formatter.presenter'),
                $c->get('console.io'),
                $c->get('event_dispatcher.listeners.stats')
              );
          }
        );
    }
898196
protected NameID encodeNameIdBasedOnNameFormat(final RequestAbstractType authnRequest,
                                                   final Object assertion,
                                                   final String nameFormat,
                                                   final SamlRegisteredService service,
                                                   final SamlRegisteredServiceServiceProviderMetadataFacade adaptor) {
        try {
            if (authnRequest instanceof AttributeQuery) {
                val query = AttributeQuery.class.cast(authnRequest);
                val nameID = query.getSubject().getNameID();
                nameID.detach();
                LOGGER.debug("Choosing NameID format [{}] with value [{}] for attribute query", nameID.getFormat(), nameID.getValue());
                return nameID;
            }

            val attribute = prepareNameIdAttribute(assertion, nameFormat, adaptor);
            val encoder = prepareNameIdEncoder(authnRequest, nameFormat, attribute, service, adaptor);
            LOGGER.debug("Encoding NameID based on [{}]", nameFormat);
            var nameId = encoder.encode(attribute);
            LOGGER.debug("Final NameID encoded with format [{}] has value [{}]", nameId.getFormat(), nameId.getValue());
            return nameId;
        } catch (final Exception e) {
            LOGGER.error(e.getMessage(), e);
        }
        return null;
    }
987121
public void debug(Throwable error, String description) {
    log(error, null, description, Level.DEBUG);
  }
373694
@Override
	public void setDescriptionMap(Map<java.util.Locale, String> descriptionMap) {
		_cpSpecificationOption.setDescriptionMap(descriptionMap);
	}
155657
public static Specification newInstance(String name)
    {
        Specification specification = new Specification();
        specification.setName(name);
        return specification;
    }
751345
public static function create(
        string $body,
        string $name = '',
        ?DescriptionFactory $descriptionFactory = null,
        ?TypeContext $context = null
    ): self {
        Assert::stringNotEmpty($name);
        Assert::notNull($descriptionFactory);

        $description = $descriptionFactory && $body !== "" ? $descriptionFactory->create($body, $context) : null;

        return new static($name, $description);
    }
37687
private static QualityIndicator<List<PointSolution>, Double> getIndicatorFromName(
      String name, List<QualityIndicator<List<PointSolution>, Double>> list) {
    QualityIndicator<List<PointSolution>, Double> result = null ;

    for (QualityIndicator<List<PointSolution>, Double> indicator : list) {
      if (indicator.getName().equals(name)) {
        result = indicator ;
      }
    }

    if (result == null) {
      throw new JMetalException("Indicator " + name + " not available") ;
    }

    return result ;
  }
381086
public Classification nameOf(String classificationName, String name) {
        return findClassificationMeta((String) classificationName, () -> {
            return "nameOf('" + classificationName + "', '" + name + "')";
        }).nameOf(name);
    }
182675
public static AccessLog.Format convertNCSAFormat(String name) {
        if (null == name) {
            return AccessLog.Format.COMMON;
        }
        AccessLog.Format format = AccessLog.Format.COMMON;
        String test = name.trim().toLowerCase();
        if ("combined".equals(test)) {
            format = AccessLog.Format.COMBINED;
        }
        return format;
    }
1031754
public void createAbout(String name, String version, String targetGoVersion, String description) {
        about = new GoPluginDescriptor.About(name, version, targetGoVersion, description, vendor, targetOperatingSystems);
    }
756688
protected void report(DiagnosticType diagnostic, Node n) {
    JSError error = JSError.make(n, diagnostic, n.toString());
    compiler.report(error);
  }
1044787
public static ErrorCode isNameValid(String name) {
        if (!isMustFieldValid(name, nameRegEx)) {
            return ErrorCode.SERVICE_INSTANCE_NAME_FORMAT_ERROR;
        }
        return ErrorCode.OK;
    }
668326
@Override
    public void visitFormalTypeParameter(final String name) {
        if (type == TYPE_SIGNATURE
                || (state != EMPTY && state != FORMAL && state != BOUND)) {
            throw new IllegalStateException();
        }
        CheckMethodAdapter.checkIdentifier(name, "formal type parameter");
        state = FORMAL;
        if (sv != null) {
            sv.visitFormalTypeParameter(name);
        }
    }