}

    public static Object realize(ModelRegistry modelRegistry, String path) {
        return modelRegistry.realize(ModelPath.nonNullValidatedPath(path), ModelType.UNTYPED);
    }

    public static <T> T realize(ModelRegistry modelRegistry, String path, Class<T> type) {
        return modelRegistry.realize(ModelPath.nonNullValidatedPath(path), ModelType.of(type));
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Conversion between identical interfaces.
// Issue 1647.

// The compiler used to not realize this was a no-op,
// so it generated a call to the non-existent function runtime.convE2E.

package main

type (
	a interface{}
	b interface{}
)

func main() {
	x := a(1)
	z := b(x)
	_ = z

     * @param type the type to project the node as
     * @param <T> the type to project the node as
     * @return the node as the given type
     */
    <T> T realize(ModelPath path, ModelType<T> type);
    <T> T realize(String path, ModelType<T> type);
    <T> T realize(String path, Class<T> type);

    /**
     * Get the fully defined model element at the given path.
     * <p>

            }
            realizedRepositories.add(realize(repository));
        }
    }

    private RealizedJavaToolchainRepository realize(JavaToolchainRepository repository) {
        Class<? extends JavaToolchainResolver> repositoryClass = getResolverClass(repository);

    abstract String getLanguageId()

    def "registers transformation for language"() {
        when:
        dsl {
            apply plugin: pluginClass
        }

        then:
        def transform = realize("languageTransforms").find { it.languageName == languageId }

        transform != null
        transform.sourceSetType == languageSourceSet
    }

        def buildModelOperation = listener.operation("Build model 'org.gradle.tooling.model.GradleProject' for root project 'root'")
        def tasks = buildModelOperation.descendants {
            it.descriptor.displayName.startsWith("Realize task")
        }
        !tasks.empty
    }

        when:
        dsl {
            apply plugin: ComponentBasePlugin
            model {
                baseComponent(ComponentSpec) {
                }
            }
        }

        then:
        realize("baseComponent") instanceof ComponentSpec
    }

    def "adds a 'components' container to the project model"() {
        when:
        dsl {
            apply plugin: ComponentBasePlugin
        }

        dsl {
            apply plugin: LanguageBasePlugin
            model {
                baseSourceSet(LanguageSourceSet) {
                }
            }
        }

        then:
        realize("baseSourceSet") instanceof LanguageSourceSet
    }

    def "adds a 'sources' container to the project model"() {
        when:
        dsl {
            apply plugin: LanguageBasePlugin
        }

        // Looks in the correct project registry for this binary
        VisualStudioExtension visualStudioExtension = getComponentModel(nativeBinary).realize("visualStudio", VisualStudioExtension.class);
        VisualStudioProjectRegistry projectRegistry = ((VisualStudioExtensionInternal) visualStudioExtension).getProjectRegistry();

        // Realize all object of type `type`
        def element = container.withType(type).iterator().next()

        when:
        def didRemoved = container.remove(element)

        then:
        didRemoved

        and:
        0 * _
    }

    def "will execute remove action when removing external provider only for realized elements"() {