scopeReferences.addNodeToScope(node.getPath(), node);
        scopeReferences.addNodeToScope(node.getPath().getParent(), node);
    }

    private void bound(Reference reference, ModelNodeInternal node) {
        ModelBinding binding = reference.binding;
        binding.onBind(node);
        reference.index.put(new NodeAtState(node.getPath(), binding.predicate.getState()), reference.owner);
    }

	err := validation.ValidatePathNoBacksteps(b.GetPath())
	if err != nil {
		return fmt.Errorf("invalid HostPath `%s`: %v", b.GetPath(), err)
	}

	if *b.pathType == v1.HostPathUnset {
		return nil
	}
	if b.noTypeChecker {
		return nil
	} else {
		return checkType(b.GetPath(), b.pathType, b.hu)
	}
}

        Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toModulePath(ModuleIdentifier module) {
        String pattern = getBase().getPath();
        if (!pattern.endsWith(MavenPattern.M2_PATTERN)) {

    private static final Comparator<Provider> PROVIDER_COMPARATOR = new Comparator<Provider>() {
        @Override
        public int compare(Provider o1, Provider o2) {
            return o1.getPath().compareTo(o2.getPath());
        }
    };

    private final String referenceType;
    private final String referenceDescription;
    private final List<Provider> providers;

    public static class Provider {

    }

    public String getTaskPath() {
        return projectPath.getPath();
    }

    public String getProjectPath() {
        return projectPath.getParent().getPath();
    }

    public String getIdentityPath() {
        return identityPath.getPath();
    }

    public String getBuildPath() {
        return buildPath.getPath();
    }

    public Class<T> getTaskType() {
        return type;
    }

        return InstanceModelView.of(modelNode.getPath(), MODEL_ELEMENT_MODEL_TYPE, new ModelElement() {
            @Override
            public String toString() {
                return getDisplayName();
            }

            @Override
            public String getName() {
                return modelNode.getPath().getName();
            }

            @Override

            } catch (CommandLineArgumentException e) {
                //we expect that all options must be applicable for each task
                throw new TaskConfigurationException(task.getPath(), "Problem configuring task " + task.getPath() + " from command line.", e);
            }

            for (OptionDescriptor commandLineOptionDescriptor : commandLineOptions) {
                final String name = commandLineOptionDescriptor.getName();

            displayName = "project " + identityPath.getPath();
        }
        return displayName;
    }

    @Override
    public BuildIdentifier getBuild() {
        return buildIdentifier;
    }

    @Override
    public Path getIdentityPath() {
        return identityPath;
    }

    @Override
    public String getProjectPath() {
        return projectPath.getPath();
    }

    public Path projectPath() {

        ModelType<?> type = reference.getType();
        return "{type: " + (type == null ? null : type.getDisplayName()) + ", path: " + getPath() + ", scope: " + getScope() + ", state: " + getState() + "}";
    }

    @Nullable
    @Override
    public ModelPath getPath() {
        return reference.getPath();
    }

    public ModelType<?> getType() {
        return reference.getType();
    }

            }
            if (reference.getPath() != null) {
                try {
                    ModelPath.validatePath(reference.getPath().getPath());
                } catch (Exception e) {
                    problems.add(ruleDefinition, "The declared model element path '" + reference.getPath().getPath() + "' used for parameter " + (i + 1) + " is not a valid path", e);
                }