// an interface.
func dataWord(conv *ir.ConvExpr, init *ir.Nodes) ir.Node {
	pos, n := conv.Pos(), conv.X
	fromType := n.Type()

	// If it's a pointer, it is its own representation.
	if types.IsDirectIface(fromType) {
		return n
	}

	isInteger := fromType.IsInteger()
	isBool := fromType.IsBoolean()
	if sc := fromType.SoleComponent(); sc != nil {
		isInteger = sc.IsInteger()
		isBool = sc.IsBoolean()
	}

        NotationParser<Object, MavenArtifact> sourceNotationParser = NotationParserBuilder
            .toType(MavenArtifact.class)
            .fromType(Provider.class, Cast.uncheckedCast(providerNotationConverter))
            .fromType(AbstractArchiveTask.class, archiveTaskNotationConverter)
            .fromType(PublishArtifact.class, publishArtifactNotationConverter)
            .converter(fileNotationConverter)
            .toComposite();

        given:
        converter.convert(_, _) >> { Number n, NotationConvertResult result -> result.converted("[${n}]") }

        and:
        def parser = NotationParserBuilder.toType(String.class).fromType(Number, converter).toComposite()

        expect:
        parser.parseNotation(12) == "[12]"
    }

    def "can add a converter that converts CharSequence notations"() {

            .fromCharSequence(stringNotationConverter)
            .fromType(MinimalExternalModuleDependency.class, minimalExternalDependencyNotationConverter)
            .converter(mapNotationConverter)
            .fromType(FileCollection.class, filesNotationConverter)
            .fromType(Project.class, projectNotationConverter)
            .fromType(DependencyFactoryInternal.ClassPathNotation.class, dependencyClassPathNotationConverter)

	cases := []struct {
		desc        string
		fromType    vertexType
		toType      vertexType
		toNamespace string
		toName      string
		start       *Graph
		expect      *Graph
	}{
		{
			// single edge from a configmap to a node, will delete edge and orphaned configmap
			desc:        "edges and source orphans are deleted, destination orphans are preserved",
			fromType:    configMapVertexType,
			toType:      nodeVertexType,

            .toType(DependencyConstraint.class)
            .fromType(MinimalExternalModuleDependency.class, minimalExternalDependencyNotationConverter)
            .fromCharSequence(stringNotationConverter)
            .converter(new DependencyMapNotationConverter<>(instantiator, DefaultDependencyConstraint.class))
            .fromType(Project.class, new DependencyConstraintProjectNotationConverter(instantiator, dependencyFactory))

                .toType(new TypeInfo<Spec<DependencyResult>>(Spec.class))
                .invalidNotationMessage("Please check the input for the DependencyInsight.dependency element.")
                .fromType(Closure.class, new ClosureToSpecNotationConverter<>(DependencyResult.class))
                .fromCharSequence(new DependencyResultSpecNotationConverter())
                .toComposite();
    }

        expect:
        spec.isSatisfiedBy("foo")
        !spec.isSatisfiedBy("FOO")
        !spec.isSatisfiedBy("bar")
    }

    def parse(def value) {
        return NotationParserBuilder.toType(Spec).fromType(Closure, converter).toComposite().parseNotation(value)
    }

        NotationParser<Object, IvyArtifact> sourceNotationParser = NotationParserBuilder
                .toType(IvyArtifact.class)
                .fromType(Provider.class, Cast.uncheckedCast(providerNotationConverter))
                .converter(archiveTaskNotationConverter)
                .converter(publishArtifactNotationConverter)
                .converter(fileNotationConverter)

        GRADLE_API      | "Gradle API"
        GRADLE_TEST_KIT | "Gradle TestKit"
        LOCAL_GROOVY    | "Local Groovy"
    }

    def parse(def value) {
        return NotationParserBuilder.toType(Dependency).fromType(DependencyFactoryInternal.ClassPathNotation, factory).toComposite().parseNotation(value)
    }