DefaultProjectComponentSelector projectSelector = (DefaultProjectComponentSelector) selector;
            ProjectComponentIdentifier projectId = projectSelector.toIdentifier();
            LocalComponentGraphResolveState projectComponent = localComponentRegistry.getComponent(projectId);
            ModuleVersionIdentifier moduleVersionId = projectComponent.getModuleVersionId();

            }
        }
    }

    @Override
    public void resolve(ComponentIdentifier identifier, ComponentOverrideMetadata componentOverrideMetadata, final BuildableComponentResolveResult result) {
        if (isProjectModule(identifier)) {
            ProjectComponentIdentifier projectId = (ProjectComponentIdentifier) identifier;
            LocalComponentGraphResolveState component = localComponentRegistry.getComponent(projectId);

    }

    @Override
    public boolean matchesStrictly(ComponentIdentifier identifier) {
        assert identifier != null : "identifier cannot be null";

        if (identifier instanceof ProjectComponentIdentifier) {
            ProjectComponentIdentifierInternal projectComponentIdentifier = (ProjectComponentIdentifierInternal) identifier;
            return projectComponentIdentifier.getIdentityPath().equals(identityPath);

            return new Identifier(NON_PRECOMPOSED_NON_ASCII, "non-ascii");
        }
        return new Identifier(NON_ASCII_CHARS, "non-ascii");
    }

    public static Identifier getFileSystemReserved() {
        return new Identifier(FILESYSTEM_RESERVED_CHARS, "filesystem");
    }

    public static Identifier getXmlMarkup() {
        return new Identifier(XML_MARKUP_CHARS, "xml markup");
    }

    private final String identifier;

    static {
        for(JansiOperatingSystemSupport osSupport : values()) {
            MAPPING.put(osSupport.identifier, osSupport);
        }
    }

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

    public String getIdentifier() {
        return identifier;
    }

	_, ok := keywords[name]
	return ok
}

// IsIdentifier reports whether name is a Go identifier, that is, a non-empty
// string made up of letters, digits, and underscores, where the first character
// is not a digit. Keywords are not identifiers.
func IsIdentifier(name string) bool {
	if name == "" || IsKeyword(name) {
		return false
	}
	for i, c := range name {

        when:
        def result = serialize(identifier, serializer)

        then:
        result.identityPath == identifier.identityPath
        result.projectPath == identifier.projectPath
        result.buildTreePath == identifier.buildTreePath
        result.projectPath() == identifier.projectPath()
        result.projectName == identifier.projectName
    }

        def version = identifier.safeForFileName().decorate("revision")
        def extraValue = identifier.decorate("extra")
        def resolver = identifier.decorate("description")
        def branch = identifier.safeForBranch().decorate("branch")
        def status = identifier.safeForFileName().decorate("status")
        def module = ivyRepo.module(organisation, moduleName, version)

	switch g {
{{- range .Entries }}
	{{- if not (or (eq .Resource.Identifier "Address") (eq .Resource.Identifier "DNSName")) }}
		case gvk.{{.Resource.Identifier}}:
			return {{.Resource.Identifier}}
	{{- end }}
{{- end }}
	}

	panic("unknown kind: " + g.String())

        given:
        def identifier = newId(mid, '1.1')
        startWithoutLockState()
        addVisitedChangingNode(identifier)

        when:
        visitor.writeLocks()

        then:
        1 * dependencyLockingProvider.persistResolvedDependencies(lockId, _, singleton(identifier), singleton(identifier))

    }

    def 'ignores visited node that is to be ignored'() {