Commits

Ruslan Lopatin committed e097801

Core: Get rid of PathBindings.

Comments (0)

Files changed (14)

org.o42a.core/src/org/o42a/core/member/local/impl/LocalOwnerStep.java

 	}
 
 	@Override
-	protected void rebuild(PathRebuilder rebuilder) {
-		rebuilder.combineWithLocalOwner(this.local.getOwner());
-	}
-
-	@Override
 	protected FieldDefinition fieldDefinition(
 			BoundPath path,
 			Distributor distributor) {

org.o42a.core/src/org/o42a/core/object/impl/ParentLocalStep.java

 	}
 
 	@Override
-	protected void combineWithLocalOwner(
-			PathRebuilder rebuilder,
-			Obj owner) {
-		if (rebuilder.isStatic()) {
-			return;
-		}
-		if (rebuilder.getPath().getBindings().isEmpty()) {
-			return;
-		}
-		rebuilder.replace(object().addEnclosingOwnerDep(owner));
-	}
-
-	@Override
 	protected FieldDefinition fieldDefinition(
 			BoundPath path,
 			Distributor distributor) {

org.o42a.core/src/org/o42a/core/ref/Ref.java

 		if (!pathReproduction.isOutOfClause()) {
 			return reproducePart(
 					reproducer,
-					pathReproducer.reproduceBindings(
-							pathReproduction.getReproducedPath()));
+					pathReproduction.getReproducedPath());
 		}
 
 		return startWithPrefix(
 				reproducer,
 				pathReproduction,
-				pathReproducer.reproduceBindings(
-						pathReproduction.getReproducedPath())
+				pathReproduction.getReproducedPath()
 				.bind(this, reproducer.getScope())
 				.append(reproducer.getPhrasePrefix().getPath()));
 	}

org.o42a.core/src/org/o42a/core/ref/path/BoundPath.java

 import static org.o42a.core.ref.path.PathWalker.DUMMY_PATH_WALKER;
 import static org.o42a.core.ref.path.impl.AncestorFragment.ANCESTOR_FRAGMENT;
 
-import java.util.Arrays;
-
 import org.o42a.analysis.Analyzer;
 import org.o42a.core.Container;
 import org.o42a.core.Distributor;
 		return getPath().isSelf();
 	}
 
-	public final PathBindings getBindings() {
-		return getRawPath().getBindings();
-	}
-
 	public final Path getPath() {
 		if (this.path != null) {
 			return this.path;
 		return lastStep.ancestor(this, location, distributor);
 	}
 
-	public final BoundPath addBinding(PathBinding<?> binding) {
-		return getRawPath().addBinding(binding).bind(this, getOrigin());
-	}
-
 	public final BoundPath append(Step step) {
 		return getRawPath().append(step).bind(this, getOrigin());
 	}
 	}
 
 	public final BoundPath append(Path path) {
-		if (path.getBindings().isEmpty()) {
-			return getRawPath().append(path).bind(this, getOrigin());
-		}
-
-		final PrefixPath prefix = toPrefix(getOrigin());
-		final Path newPath = path.prefixWith(prefix);
-
-		return newPath.bind(this, getOrigin());
+		return getRawPath().append(path).bind(this, getOrigin());
 	}
 
 	public final BoundPath append(BoundPath path) {
 		if (newPath == null) {
 			return null;
 		}
-		if (getBindings().isEmpty()) {
-			return newPath;
-		}
-
-		final PathBindings newBindings = getBindings().modifyPaths(modifier);
-
-		if (newBindings == null) {
-			return null;
-		}
-
-		final Path rawPath = newPath.getRawPath();
-
-		return new Path(
-				rawPath.getKind(),
-				newBindings,
-				rawPath.isStatic(),
-				rawPath.getSteps()).bind(newPath, newPath.getOrigin());
+		return newPath;
 	}
 
 	public final BoundPath prefixWith(PrefixPath prefix) {
 							new Step[] {ErrorStep.ERROR_STEP});
 					this.path = new Path(
 							this.path.getKind(),
-							this.path.getBindings(),
 							this.path.isStatic(),
 							steps);
 					tracker.abortedAt(prev, step);
 				}
 
 				final Step[] replacementSteps = replacement.getSteps();
-				final PathBindings replacementBindings;
-
-				if (replacement.getBindings().isEmpty()) {
-					replacementBindings = this.path.getBindings();
-				} else {
-
-					final PrefixPath replacementPrefix = toPrefix(i);
-
-					replacementBindings =
-							replacement.getBindings().prefixWith(
-									replacementPrefix);
-				}
 
 				if (replacement.isAbsolute()) {
 					// Replacement is an absolute path.
 							replacementSteps);
 					this.path = new Path(
 							PathKind.ABSOLUTE_PATH,
-							replacementBindings,
 							true,
 							steps);
 					// Continue from the ROOT.
 							replacementSteps);
 					this.path = new Path(
 							this.path.getKind(),
-							replacementBindings,
 							this.path.isStatic() || replacement.isStatic(),
 							steps);
 				}
 		final Step[] steps = removeOddFragments();
 
 		if (steps.length <= 1) {
-			return new Path(
-					getKind(),
-					this.path.getBindings(),
-					isStatic(),
-					steps);
+			return new Path(getKind(), isStatic(), steps);
 		}
 
 		final Step[] rebuilt = rebuild(steps);
 			return rawPath;
 		}
 
-		return new Path(
-				getKind(),
-				this.path.getBindings(),
-				isStatic(),
-				rebuilt);
-	}
-
-	private PrefixPath toPrefix(int length) {
-
-		final Step[] steps = Arrays.copyOf(getSteps(), length);
-		final Path path =
-				new Path(getKind(), getPath().getBindings(), isStatic(), steps);
-
-		return path.toPrefix(getOrigin());
+		return new Path(getKind(), isStatic(), rebuilt);
 	}
 
 	private Step[] removeOddFragments() {

org.o42a.core/src/org/o42a/core/ref/path/Path.java

 
 import static org.o42a.analysis.use.User.dummyUser;
 import static org.o42a.core.member.MemberName.fieldName;
-import static org.o42a.core.ref.path.PathBindings.NO_PATH_BINDINGS;
 import static org.o42a.core.ref.path.PathKind.ABSOLUTE_PATH;
 import static org.o42a.core.ref.path.PathKind.RELATIVE_PATH;
 import static org.o42a.util.string.Capitalization.CASE_INSENSITIVE;
 	public static final Path ROOT_PATH = ABSOLUTE_PATH.emptyPath();
 	public static final Path SELF_PATH = RELATIVE_PATH.emptyPath();
 	public static final Path VOID_PATH =
-			new Path(ABSOLUTE_PATH, NO_PATH_BINDINGS, true, new VoidStep());
+			new Path(ABSOLUTE_PATH, true, new VoidStep());
 	public static final Path FALSE_PATH =
-			new Path(ABSOLUTE_PATH, NO_PATH_BINDINGS, true, new FalseStep());
+			new Path(ABSOLUTE_PATH, true, new FalseStep());
 
 	public static Path absolutePath(
 			CompilerContext context,
 	public static Path modulePath(Name moduleName) {
 		return new Path(
 				ABSOLUTE_PATH,
-				NO_PATH_BINDINGS,
 				true,
 				new ModuleStep(moduleName));
 	}
 
 	private final PathKind kind;
 	private final Step[] steps;
-	private final PathBindings bindings;
 	private final boolean isStatic;
 
-	Path(
-			PathKind kind,
-			PathBindings bindings,
-			boolean isStatic,
-			Step... steps) {
+	Path(PathKind kind, boolean isStatic, Step... steps) {
 		this.kind = kind;
-		this.bindings = bindings;
 		this.isStatic = kind.isAbsolute() ? true : isStatic;
 		this.steps = steps;
 		assert assertStepsNotNull(steps);
 		return this.steps.length == 0 && !isStatic();
 	}
 
-	public final PathBindings getBindings() {
-		return this.bindings;
-	}
-
 	public final Step[] getSteps() {
 		return this.steps;
 	}
 		final PathKind pathKind = step.getPathKind();
 
 		if (pathKind.isAbsolute()) {
-			return new Path(pathKind, NO_PATH_BINDINGS, true, step);
+			return new Path(pathKind, true, step);
 		}
 
 		final Step[] newSteps = ArrayUtil.append(this.steps, step);
 
-		return new Path(getKind(), getBindings(), isStatic(), newSteps);
+		return new Path(getKind(), isStatic(), newSteps);
 	}
 
 	public final Path append(MemberKey memberKey) {
 			return path;
 		}
 
-		assert path.assertNoBindings();
-
 		final Step[] newSteps = ArrayUtil.append(getSteps(), path.getSteps());
 
-		return new Path(
-				getKind(),
-				getBindings(),
-				isStatic() || path.isStatic(),
-				newSteps);
+		return new Path(getKind(), isStatic() || path.isStatic(), newSteps);
 	}
 
 	public final Path cut(int stepsToCut) {
 		final Step[] newSteps =
 				Arrays.copyOf(this.steps, this.steps.length - stepsToCut);
 
-		return new Path(getKind(), getBindings(), isStatic(), newSteps);
+		return new Path(getKind(), isStatic(), newSteps);
 	}
 
 	public final BoundPath bind(LocationInfo location, Scope origin) {
 		final Step[] steps =
 				ArrayUtil.prepend(new StaticStep(origin), getSteps());
 
-		return new Path(
-				getKind(),
-				getBindings(),
-				true,
-				steps).bind(location, origin);
+		return new Path(getKind(), true, steps).bind(location, origin);
 	}
 
 	public final PrefixPath toPrefix(Scope start) {
 		return toString(null, length);
 	}
 
-	final boolean assertNoBindings() {
-		assert getBindings().isEmpty() :
-			"Bindings present in " + this + ": " + getBindings();
-		return true;
-	}
-
-	final Path addBinding(PathBinding<?> binding) {
-		return new Path(
-				getKind(),
-				getBindings().addBinding(binding),
-				isStatic(),
-				getSteps());
-	}
-
 	Path prefixWith(PrefixPath prefix) {
 		if (prefix.isEmpty()) {
 			return this;
 		}
-		if (getBindings().isEmpty()) {
-			return prefix.getBoundPath()
-					.getRawPath()
-					.append(this);
-		}
-
-		final PathBindings newBindings =
-				getBindings().prefixWith(prefix);
-
-		return prefix.getBoundPath()
-				.getRawPath()
-				.append(this, newBindings);
+		return prefix.getBoundPath().getRawPath().append(this);
 	}
 
 	String toString(Object origin, int length) {
 		return true;
 	}
 
-	private final Path append(Path path, PathBindings bindings) {
-		assert path != null :
-			"Path to append not specified";
-
-		final PathKind kind;
-
-		if (path.isAbsolute()) {
-			kind = ABSOLUTE_PATH;
-		} else {
-			kind = getKind();
-		}
-
-		final Step[] newSteps = ArrayUtil.append(getSteps(), path.getSteps());
-
-		return new Path(
-				kind,
-				bindings,
-				isStatic() || path.isStatic(),
-				newSteps);
-	}
-
 }

org.o42a.core/src/org/o42a/core/ref/path/PathBinding.java

-/*
-    Compiler Core
-    Copyright (C) 2011,2012 Ruslan Lopatin
-
-    This file is part of o42a.
-
-    o42a is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    o42a is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-package org.o42a.core.ref.path;
-
-import org.o42a.core.st.Reproducer;
-
-
-public interface PathBinding<B> {
-
-	B getBound();
-
-	PathBinding<B> modifyPath(PathModifier modifier);
-
-	PathBinding<B> prefixWith(PrefixPath prefix);
-
-	PathBinding<B> reproduce(Reproducer reproducer);
-
-}

org.o42a.core/src/org/o42a/core/ref/path/PathBindings.java

-/*
-    Compiler Core
-    Copyright (C) 2011,2012 Ruslan Lopatin
-
-    This file is part of o42a.
-
-    o42a is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    o42a is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-package org.o42a.core.ref.path;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-
-public final class PathBindings {
-
-	public static final PathBindings NO_PATH_BINDINGS = new PathBindings();
-
-	private Map<PathBinding<?>, PathBinding<?>> bindings;
-
-	PathBindings() {
-	}
-
-	PathBindings(Map<PathBinding<?>, PathBinding<?>> bindings) {
-		this.bindings = bindings;
-	}
-
-	public final boolean isEmpty() {
-		return this.bindings == null;
-	}
-
-	public final int size() {
-		return isEmpty() ? 0 : this.bindings.size();
-	}
-
-	public final <B> B boundOf(PathBinding<B> binding) {
-		assert !isEmpty() :
-			"No path bindings";
-
-		@SuppressWarnings("unchecked")
-		final PathBinding<B> found =
-				(PathBinding<B>) this.bindings.get(binding);
-
-		assert found != null :
-			"Path binding not found: " + binding;
-
-		return found.getBound();
-	}
-
-	@Override
-	public String toString() {
-		if (isEmpty()) {
-			return "PathBindings{}";
-		}
-		return "PathBindings" + this.bindings;
-	}
-
-	PathBindings addBinding(PathBinding<?> binding) {
-
-		final Map<PathBinding<?>, PathBinding<?>> bindings;
-
-		if (this.bindings == null) {
-			bindings = Collections.<PathBinding<?>, PathBinding<?>>singletonMap(
-					binding,
-					binding);
-		} else {
-
-			final HashMap<PathBinding<?>, PathBinding<?>> newBindings =
-					new HashMap<PathBinding<?>, PathBinding<?>>(
-							this.bindings.size() + 1);
-
-			newBindings.putAll(this.bindings);
-			newBindings.put(binding, binding);
-
-			bindings = Collections.unmodifiableMap(newBindings);
-		}
-
-		return new PathBindings(bindings);
-	}
-
-	PathBindings modifyPaths(PathModifier modifier) {
-		if (isEmpty()) {
-			return this;
-		}
-
-		final HashMap<PathBinding<?>, PathBinding<?>> newBindings =
-				new HashMap<PathBinding<?>, PathBinding<?>>(
-						this.bindings.size());
-
-		for (Map.Entry<PathBinding<?>, PathBinding<?>> e
-				: this.bindings.entrySet()) {
-
-			final PathBinding<?> newBinding = e.getValue().modifyPath(modifier);
-
-			newBindings.put(e.getKey(), newBinding);
-		}
-
-
-		return new PathBindings(newBindings);
-	}
-
-	PathBindings prefixWith(PrefixPath prefix) {
-
-		final PathBindings prefixBindings = prefix.getBindings();
-
-		if (isEmpty()) {
-			return prefixBindings;
-		}
-
-		final HashMap<PathBinding<?>, PathBinding<?>> newBindings;
-
-		if (!prefixBindings.isEmpty()) {
-			newBindings = new HashMap<PathBinding<?>, PathBinding<?>>(
-					this.bindings.size() + prefixBindings.size());
-			newBindings.putAll(prefixBindings.bindings);
-		} else {
-			newBindings = new HashMap<PathBinding<?>, PathBinding<?>>(
-					this.bindings.size());
-		}
-
-		for (Map.Entry<PathBinding<?>, PathBinding<?>> e
-				: this.bindings.entrySet()) {
-
-			final PathBinding<?> newBinding = e.getValue().prefixWith(prefix);
-
-			newBindings.put(e.getKey(), newBinding);
-		}
-
-		return new PathBindings(newBindings);
-	}
-
-	final Map<? extends PathBinding<?>, ? extends PathBinding<?>> bindings() {
-		return this.bindings;
-	}
-
-}

org.o42a.core/src/org/o42a/core/ref/path/PathKind.java

 import static org.o42a.analysis.use.User.dummyUser;
 import static org.o42a.core.member.MemberRegistry.noDeclarations;
 import static org.o42a.core.ref.path.Path.SELF_PATH;
-import static org.o42a.core.ref.path.PathBindings.NO_PATH_BINDINGS;
 import static org.o42a.core.ref.path.PathReproduction.outOfClausePath;
 import static org.o42a.core.ref.path.PathReproduction.reproducedPath;
 import static org.o42a.core.ref.path.PathReproduction.unchangedPath;
 	private final Path emptyPath;
 
 	PathKind(boolean isStatic) {
-		this.emptyPath = new Path(this, NO_PATH_BINDINGS, isStatic);
+		this.emptyPath = new Path(this, isStatic);
 	}
 
 	public final boolean isAbsolute() {
 			if (reproduction.isOutOfClause()) {
 				return outOfClausePath(
 						reproduced,
-						reproduction.getExternalPath().append(
-								new Path(
-										RELATIVE_PATH,
-										NO_PATH_BINDINGS,
-										path.isStatic(),
-										copyOfRange(
-												steps,
-												i + 1,
-												steps.length))));
+						reproduction.getExternalPath().append(new Path(
+								RELATIVE_PATH,
+								path.isStatic(),
+								copyOfRange(steps, i + 1, steps.length))));
 			}
 
 			toScope = resolution.getResult().getScope();
 
 		return reproducedPath(new Path(
 				RELATIVE_PATH,
-				NO_PATH_BINDINGS,
 				path.isStatic(),
 				newSteps));
 	}

org.o42a.core/src/org/o42a/core/ref/path/PathNormalizer.java

 	}
 
 	NormalPath normalize() {
-		if (!getPath().getBindings().isEmpty()) {
-			return unnormalized();
-		}
 		new Cancel(getNormalizer());
 		if (isStatic()) {
 			return normalizeStatic();

org.o42a.core/src/org/o42a/core/ref/path/PathRebuilder.java

 */
 package org.o42a.core.ref.path;
 
-import static org.o42a.core.ref.path.PathBindings.NO_PATH_BINDINGS;
-
 import java.util.Arrays;
 
 import org.o42a.core.Scope;
-import org.o42a.core.object.Obj;
 import org.o42a.core.source.CompilerContext;
 import org.o42a.core.source.LocationInfo;
 import org.o42a.util.ArrayUtil;
 	public final BoundPath restPath(Scope newOrigin) {
 		return new Path(
 				this.path.getKind(),
-				NO_PATH_BINDINGS,
 				this.path.isStatic(),
 				Arrays.copyOfRange(
 						this.steps,
 				.bind(this, newOrigin);
 	}
 
-	public final void combineWithLocalOwner(Obj owner) {
-		this.previousStep.combineWithLocalOwner(this, owner);
-	}
-
 	public final Step getPreviousStep() {
 		return this.previousStep;
 	}

org.o42a.core/src/org/o42a/core/ref/path/PathReproducer.java

 */
 package org.o42a.core.ref.path;
 
-import java.util.HashMap;
-
 import org.o42a.core.Container;
 import org.o42a.core.Distributor;
 import org.o42a.core.Scope;
 
 	private final Reproducer reproducer;
 	private final BoundPath reproducingPath;
-	private final PathBindings reproducing;
-	private final HashMap<PathBinding<?>, PathBinding<?>> reproduced;
-	private final HashMap<PathBinding<?>, PathBinding<?>> newBindings;
 
 	PathReproducer(Reproducer reproducer, BoundPath reproducingPath) {
 		this.reproducer = reproducer;
 		this.reproducingPath = reproducingPath;
-		this.reproducing = reproducingPath.getBindings();
-
-		final int size = this.reproducing.size();
-
-		this.reproduced = new HashMap<PathBinding<?>, PathBinding<?>>(size);
-		this.newBindings = new HashMap<PathBinding<?>, PathBinding<?>>(size);
-		if (!this.reproducing.isEmpty()) {
-			this.newBindings.putAll(this.reproducing.bindings());
-		}
 	}
 
 	PathReproducer(Reproducer reproducer, PathReproducer prototype) {
 		this.reproducer = reproducer;
 		this.reproducingPath = prototype.reproducingPath;
-		this.reproducing = prototype.reproducing;
-		this.reproduced = prototype.reproduced;
-		this.newBindings = prototype.newBindings;
 	}
 
 	public final BoundPath getReproducingPath() {
 		return getReproducingPath().getKind().reproduce(this);
 	}
 
-	public final <B> PathBinding<B> reproduce(PathBinding<B> binding) {
-
-		@SuppressWarnings("unchecked")
-		final PathBinding<B> cached =
-				(PathBinding<B>) this.reproduced.get(binding);
-
-		if (cached != null) {
-			return cached;
-		}
-
-		final PathBinding<B> reproduction = binding.reproduce(getReproducer());
-
-		this.reproduced.put(binding, reproduction);
-		this.newBindings.remove(binding);
-
-		return reproduction;
-	}
-
-	public Path reproduceBindings(Path path) {
-		if (this.newBindings.isEmpty()) {
-			return path;
-		}
-		for (PathBinding<?> binding : this.reproduced.values()) {
-			this.newBindings.put(binding, binding);
-		}
-
-		final PathBindings bindings = path.getBindings();
-
-		if (!bindings.isEmpty()) {
-			this.newBindings.putAll(bindings.bindings());
-		}
-
-		return new Path(
-				path.getKind(),
-				new PathBindings(this.newBindings),
-				path.isStatic(),
-				path.getSteps());
-
-	}
-
 }

org.o42a.core/src/org/o42a/core/ref/path/PrefixPath.java

 	}
 
 	public final boolean isEmpty() {
-		return getPrefix().isSelf() && getPrefix().getBindings().isEmpty();
+		return getPrefix().isSelf();
 	}
 
 	public final boolean emptyFor(ScopeInfo scoped) {
 			return startWithPrefix(reproducer, pathReproduction);
 		}
 
-		final Path reproducedPart = pathReproducer.reproduceBindings(
-				pathReproduction.getReproducedPath());
+		final Path reproducedPart = pathReproduction.getReproducedPath();
 
 		return startWithPrefix(reproducer, pathReproduction)
 				.append(reproducedPart);
 		return this.prefix.toString(this.start, this.prefix.getSteps().length);
 	}
 
-	final PathBindings getBindings() {
-		return getBoundPath().getBindings();
-	}
-
 	final BoundPath getBoundPath() {
 		if (this.boundPath != null) {
 			return this.boundPath;

org.o42a.core/src/org/o42a/core/ref/path/StaticStep.java

 package org.o42a.core.ref.path;
 
 import static org.o42a.core.ref.Prediction.exactPrediction;
-import static org.o42a.core.ref.path.PathBindings.NO_PATH_BINDINGS;
 import static org.o42a.core.ref.path.PathReproduction.reproducedPath;
 
 import org.o42a.core.Container;
 
 	@Override
 	public Path toPath() {
-		return new Path(getPathKind(), NO_PATH_BINDINGS, true, this);
+		return new Path(getPathKind(), true, this);
 	}
 
 	@Override

org.o42a.core/src/org/o42a/core/ref/path/Step.java

 */
 package org.o42a.core.ref.path;
 
-import static org.o42a.core.ref.path.PathBindings.NO_PATH_BINDINGS;
 import static org.o42a.core.ref.path.impl.AncestorFragment.ANCESTOR_FRAGMENT;
 
 import org.o42a.analysis.Analyzer;
 import org.o42a.core.Scope;
 import org.o42a.core.ir.op.PathOp;
 import org.o42a.core.member.field.FieldDefinition;
-import org.o42a.core.object.Obj;
 import org.o42a.core.ref.Ref;
 import org.o42a.core.ref.RefUsage;
 import org.o42a.core.ref.path.impl.PathFieldDefinition;
 	}
 
 	public Path toPath() {
-		return new Path(getPathKind(), NO_PATH_BINDINGS, false, this);
+		return new Path(getPathKind(), false, this);
 	}
 
 	@Override
 	}
 
 	/**
-	 * Combines the current step with a preceding local owner step.
-	 *
-	 * <p>This method is called during the bound path rebuild when the preceding
-	 * step is a local owner one. The combining may replace the preceding step
-	 * or path fragment.</p>
-	 *
-	 * @param rebuilder path rebuilder
-	 * @param owner local owner.
-	 */
-	protected void combineWithLocalOwner(
-			PathRebuilder rebuilder,
-			Obj owner) {
-	}
-
-	/**
 	 * Builds an ancestor of an object pointed by the path.
 	 *
 	 * <p>This method is called on the last step of the path.</p>