internal
class UnexpectedDuplicateBlock(val identifier: TopLevelBlockId, override val location: IntRange) :
    UnexpectedBlock("Unexpected `$identifier` block found. Only one `$identifier` block is allowed per script.")


internal
class UnexpectedBlockOrder(val identifier: TopLevelBlockId, override val location: IntRange, expectedFirstIdentifier: TopLevelBlockId) :

                                         File file) {
        this.identifier = identifier;
        this.variant = new DefaultResolvedVariantResult(identifier.getComponentIdentifier(), variantDisplayName, variantAttributes, capabilities, null);
        this.type = type;
        this.file = file;
    }

    @Override
    public String toString() {
        return identifier.getDisplayName();
    }

    @Override

    private final ComponentArtifactIdentifier identifier;
    private final Class<? extends Artifact> type;
    private final Throwable failure;

    public DefaultUnresolvedArtifactResult(ComponentArtifactIdentifier identifier, Class<? extends Artifact> type, Throwable failure) {
        this.identifier = identifier;
        this.type = type;
        this.failure = failure;
    }

    @Override

    private final String name;
    private final Identifier identifier;
    private final DisplayName displayName;
    private final ImmutableAttributes attributes;
    private final ImmutableList<? extends ComponentArtifactMetadata> artifacts;
    private final ImmutableCapabilities capabilitiesMetadata;

		return id.(runtime.Identifier)
	}
	identifier, err := json.Marshal(result)
	if err != nil {
		klog.Fatalf("Failed marshaling identifier for codec: %v", err)
	}
	identifiersMap.Store(result, runtime.Identifier(identifier))
	return runtime.Identifier(identifier)
}

// Decode attempts a decode of the object, then tries to convert it to the internal version. If into is provided and the decoding is

    }

    private static class Id implements ClassLoaderId {
        private final ClassLoaderScopeIdentifier identifier;
        private final boolean export;

        public Id(ClassLoaderScopeIdentifier identifier, boolean export) {
            this.identifier = identifier;
            this.export = export;
        }

        @Override
        public boolean equals(Object o) {

    /**
     * To match strictly means that the given identifier needs to have
     * equal group, module name and version.
     * It does not smartly match dynamic versions,
     * e.g. '1.+' selector does not strictly match '1.2' identifier.
     *
     * @return if this selector matches exactly the given identifier.
     */
    boolean matchesStrictly(ModuleVersionIdentifier identifier);

    /**

public enum RuntimeShadedJarType {

    API("api"),
    TEST_KIT("test-kit");

    private final String identifier;

    RuntimeShadedJarType(String identifier) {
        this.identifier = identifier;
    }

    public String getIdentifier() {
        return identifier;
    }

    internal val arrayOf = Name.identifier("arrayOf")
    internal val arrayTypeToArrayOfCall = run {
        StandardClassIds.primitiveArrayTypeByElementType.values + StandardClassIds.unsignedArrayTypeByElementType.values
    }.associateWith { it.correspondingArrayOfCallFqName() }

    private fun ClassId.correspondingArrayOfCallFqName(): Name =
        Name.identifier("${shortClassName.identifier.replaceFirstChar(Char::lowercaseChar)}Of")

    private final ModuleVersionIdentifier identifier;

    public DefaultResolvedModuleVersion(ModuleVersionIdentifier identifier) {
        this.identifier = identifier;
    }

    @Override
    public String toString() {
        return identifier.toString();
    }

    @Override
    public ModuleVersionIdentifier getId() {
        return identifier;
    }