plugins/org.eclipse.dltk.javascript.core/src/org/eclipse/dltk/internal/javascript/ti/Value.java - dltk/org.eclipse.dltk.javascript - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010 xored software, Inc.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     xored software, Inc. - initial API and Implementation (Alex Panchenko)
  *******************************************************************************/
 package org.eclipse.dltk.internal.javascript.ti;

 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;

 import org.eclipse.dltk.javascript.core.JavaScriptPlugin;
 import org.eclipse.dltk.javascript.core.Types;
 import org.eclipse.dltk.javascript.typeinference.IValueCollection;
 import org.eclipse.dltk.javascript.typeinference.IValueReference;
 import org.eclipse.dltk.javascript.typeinference.ReferenceKind;
 import org.eclipse.dltk.javascript.typeinference.ReferenceLocation;
 import org.eclipse.dltk.javascript.typeinfo.IRProperty;
 import org.eclipse.dltk.javascript.typeinfo.IRSimpleType;
 import org.eclipse.dltk.javascript.typeinfo.IRType;
 import org.eclipse.dltk.javascript.typeinfo.ITypeSystem;
 import org.eclipse.dltk.javascript.typeinfo.JSTypeSet;
 import org.eclipse.dltk.javascript.typeinfo.ReferenceSource;
 import org.eclipse.dltk.javascript.typeinfo.model.Type;

 public class Value extends ImmutableValue {

 	public Value() {
 	}

 	public Value(ImmutableValue value) {
 		super(value);
 	}

 	@Override
 	public void setDeclaredType(IRType declaredType) {
 		this.declaredType = declaredType;
 	}

 	@Override
 	public void addType(IRType type) {
 		if (type != null) {
 			this.types.add(type);
 		}
 	}

 	@Override
 	public void setKind(ReferenceKind kind) {
 		this.kind = kind;
 	}

 	@Override
 	public void setLocation(ReferenceLocation location) {
 		this.location = location;
 	}

 	@Override
 	public void setAttribute(String key, Object value) {
 		if (value != null) {
 			if (attributes == null) {
 				attributes = new HashMap<String, Object>();
 			}
 			attributes.put(key, value);
 		} else {
 			if (attributes != null) {
 				attributes.remove(key);
 			}
 		}
 	}

 	@Override
 	public void deleteChild(String name, boolean force) {
 		if (force) {
 			children.remove(name);
 			inherited.remove(name);
 		} else {
 			if (deletedChildren == null) {
 				deletedChildren = new HashSet<String>();
 			}
 			deletedChildren.add(name);
 		}
 	}

 	@Override
 	public void putChild(String name, IValue value) {
 		inherited.put(name, value);
 	}

 	private static class CreateChildOperation implements Handler<Set<IValue>> {

 		private final String childName;

 		public CreateChildOperation(String childName) {
 			this.childName = childName;
 		}

 		public void process(ImmutableValue value, Set<IValue> result) {
 			if (result.isEmpty() && !value.hasReferences()) {
 				IValue child = value.createChild(childName, 0);
 				if (child != null)
 					result.add(child);
 			}
 		}

 	}

 	@Override
 	public IValue createChild(String name, int flags) {
 		IValue child = children.get(name);
 		if (child == null) {
 			child = inherited.get(name);
 			if (child == null) {
 				if ((flags & CREATE) == 0) {
 					// creating new child, so ignore external elements
 					child = findMember(name, false);
 					if (child != null) {
 						return child;
 					}
 				}
 				if (hasReferences()) {
 					Set<IValue> result = new HashSet<IValue>();
 					execute(this, new CreateChildOperation(name), result,
 							new HashSet<IValue>());
 					if (!result.isEmpty()) {
 						return result.iterator().next();
 					}
 				}
 				child = new Value();
 				children.put(name, (Value) child);
 				childCreated(name);
 			}
 		}
 		return child;
 	}

 	@Override
 	public void clear() {
 		references.clear();
 		children.clear();
 		inherited.clear();
 		types.clear();
 	}

 	@SuppressWarnings("serial")
 	static class DeepValueRecursionException extends RuntimeException {
 	}

 	private static final ThreadLocal<AtomicBoolean> recursionErrorReported = new ThreadLocal<AtomicBoolean>() {
 		@Override
 		protected AtomicBoolean initialValue() {
 			return new AtomicBoolean();
 		}
 	};

 	@Override
 	public void addValue(IValue src) {
 		if (src instanceof ImmutableValue) {
 			final IdentityHashMap<ImmutableValue, ImmutableValue> processing = new IdentityHashMap<ImmutableValue, ImmutableValue>();
 			try {
 				addValueRecursive((ImmutableValue) src, processing, 0);
 			} catch (DeepValueRecursionException e) {
 				e.printStackTrace();
 				if (recursionErrorReported.get().compareAndSet(false, true)) {
 					String msg = "Deep recursion while copying the value";
 					final ReferenceSource source = ITypeSystem.CURRENT
 							.getCurrentSource();
 					if (source != null) {
 						msg += " when processing " + source;
 					}
 					JavaScriptPlugin.error(msg, e);
 				}
 			}
 			// translate references, so they point to the new value
 			for (Map.Entry<ImmutableValue, ImmutableValue> entry : processing
 					.entrySet()) {
 				final ImmutableValue input = entry.getKey();
 				final ImmutableValue output = entry.getValue();
 				for (IValue ref : input.references) {
 					IValue refOut = processing.get(ref);
 					if (refOut == null) {
 						refOut = ref;
 					}
 					output.references.add(refOut);
 				}
 			}
 		} else {
 			// ElementValue is handled in this branch.
 			final IRType srcType = src.getDeclaredType();
 			if (srcType != null) {
 				types.add(srcType);
 			}
 			types.addAll(src.getTypes());
 			if (src.getKind() == ReferenceKind.METHOD) {
 				final Object element = src.getAttribute(
 						IReferenceAttributes.ELEMENT, false);
 				if (element != null) {
 					setAttribute(IReferenceAttributes.ELEMENT, element);
 				}
 				final IValue returnType = src.getChild(
 						IValueReference.FUNCTION_OP, false);
 				if (returnType != null) {
 					final JSTypeSet myReturnTypes = createChild(
 							IValueReference.FUNCTION_OP, 0).getTypes();
 					myReturnTypes.addAll(returnType.getTypes());
 					myReturnTypes.addAll(returnType.getDeclaredTypes());
 				}
 			} else if (src.getKind() == ReferenceKind.PROPERTY
 					&& !isPrimitiveValue(srcType)) {
 				/*
 				 * to optimize memory usage remember *static non-primitive
 				 * properties* only
 				 */
 				final Object element = src.getAttribute(
 						IReferenceAttributes.ELEMENT, false);
 				if (element != null && element instanceof IRProperty
 						&& ((IRProperty) element).isStatic()) {
 					setAttribute(IReferenceAttributes.ELEMENT, element);
 				}
 			}
 		}
 	}

 	private static boolean isPrimitiveValue(IRType type) {
 		if (type instanceof IRSimpleType) {
 			final Type target = ((IRSimpleType) type).getTarget();
 			return target == Types.BOOLEAN || target == Types.STRING
 					|| target == Types.NUMBER;
 		} else {
 			return false;
 		}
 	}

 	@Override
 	public void addReference(IValue src) {
 		assert src != null;
 		if (src == this)
 			return;
 		references.add(src);
 	}

 	@Override
 	public void removeReference(IValue value) {
 		references.remove(value);
 	}

 	private void addValueRecursive(ImmutableValue src,
 			Map<ImmutableValue, ImmutableValue> processing, int depth) {
 		if (!processing.containsKey(src)) {
 			processing.put(src, this);
 			if (depth > 8) {
 				throw new DeepValueRecursionException();
 			}
 			if (src.declaredType != null) {
 				types.add(src.declaredType);
 			} else {
 				types.addAll(src.types);
 			}
 			// (references will be copied later)
 			if (src.attributes != null) {
 				if (attributes == null) {
 					attributes = new HashMap<String, Object>();
 				}
 				attributes.putAll(src.attributes);
 			}
 			for (Map.Entry<String, ImmutableValue> entry : src.children
 					.entrySet()) {
 				IValue child = createChild(entry.getKey(), 0);
 				if (child instanceof Value) {
 					((Value) child).addValueRecursive(entry.getValue(),
 							processing, depth + 1);
 				}
 			}
 			if (src.kind != ReferenceKind.UNKNOWN
 					&& kind == ReferenceKind.UNKNOWN) {
 				kind = src.kind;
 			}
 			if (src.location != ReferenceLocation.UNKNOWN
 					&& location == ReferenceLocation.UNKNOWN) {
 				location = src.location;
 			} else if (src.location != ReferenceLocation.UNKNOWN
 					&& src.declaredType != null
 					&& src.kind == ReferenceKind.FUNCTION) {
 				// if src location is known and the src is a function, then we
 				// need to remember the location if this function is used as a
 				// local type (through the assignment)
 				if (attributes == null) {
 					attributes = new HashMap<String, Object>();
 				}
 				attributes.put(IReferenceAttributes.LOCAL_TYPE_LOCATION,
 						src.location);
 			}
 		}
 	}

 	public void putDirectChild(String name, ImmutableValue value) {
 		children.put(name, value);
 	}

 	public void copyChilds(ImmutableValue value) {
 		if (value.hasReferences()) {
 			execute(value, new Handler<Map<String, ImmutableValue>>() {
 				public void process(ImmutableValue value,
 						Map<String, ImmutableValue> result) {
 					result.putAll(value.children);
 				};
 			}, this.children, new HashSet<IValue>());
 		} else {
 			this.children.putAll(value.children);
 		}
 	}

 	public void resolveLazyValues(Set<Value> visited) {
 		if (visited.add(this)) {
 			for (IValue value : references) {
 				if (value instanceof ILazyValue
 						&& !((ILazyValue) value).isResolved()) {
 					((ILazyValue) value).setFinalResolve();
 				} else if (value instanceof Value) {
 					((Value) value).resolveLazyValues(visited);
 				}
 			}
 			for (ImmutableValue value : children.values()) {
 				if (value instanceof Value)
 					((Value) value).resolveLazyValues(visited);
 			}

 			if (attributes != null) {
 				for (Object attibute : attributes.values()) {
 					if (attibute instanceof IValueProvider) {
 						IValue value = ((IValueProvider) attibute).getValue();
 						if (value instanceof Value) {
 							((Value) value).resolveLazyValues(visited);
 						}
 					}
 				}
 			}
 		}
 	}

 	public ImmutableValue getImmutableValue(Map<Object, Object> visited) {
 		ImmutableValue immutableValue = (ImmutableValue) visited.get(this);
 		if (immutableValue != null)
 			return immutableValue;

 		if (this instanceof ILazyValue) {
 			((ILazyValue) this).resolve();
 		}

 		JSTypeSet typeSet = JSTypeSet.create();
 		typeSet.addAll(types);
 		Set<String> deletedChilds = null;
 		if (deletedChildren != null) {
 			deletedChilds = new HashSet<String>(deletedChildren.size(), 0.9f);
 			deletedChilds.addAll(deletedChildren);
 		}

 		Map<String, ImmutableValue> childs = new HashMap<String, ImmutableValue>(
 				children.size(), 0.9f);
 		Map<String, IValue> inherits = new HashMap<String, IValue>(
 				inherited.size(), 0.9f);
 		Set<IValue> refers = new HashSet<IValue>(references.size(), 0.9f);
 		Map<String, Object> atts = null;
 		if (attributes != null) {
 			atts = new HashMap<String, Object>(attributes.size(), 0.9f);
 			for (Map.Entry<String, Object> entry : attributes.entrySet()) {
 				if (entry.getValue() instanceof Value) {
 					atts.put(entry.getKey(), ((Value) entry.getValue())
 							.getImmutableValue(visited));
 				} else if (entry.getValue() instanceof IValueCollection) {
 					atts.put(entry.getKey(), ImmutableValueCollection
 							.getImmutableValueCollection(
 									(IValueCollection) entry.getValue(),
 									visited));

 				} else {
 					atts.put(entry.getKey(), entry.getValue());
 				}
 			}
 		}
 		immutableValue = new ImmutableValue(declaredType, typeSet,
 				deletedChilds, kind, location, childs, inherits, refers, atts);
 		visited.put(this, immutableValue);

 		for (IValue value : references) {
 			if (value instanceof Value) {
 				refers.add(((Value) value).getImmutableValue(visited));
 			} else {
 				refers.add(value);
 			}
 		}

 		for (Map.Entry<String, ImmutableValue> entry : children.entrySet()) {
 			if (entry.getValue() instanceof Value) {
 				childs.put(entry.getKey(),
 						((Value) entry.getValue()).getImmutableValue(visited));
 			} else {
 				childs.put(entry.getKey(), entry.getValue());
 			}
 		}

 		for (Map.Entry<String, IValue> entry : inherited.entrySet()) {
 			if (entry.getValue() instanceof Value)
 				inherits.put(entry.getKey(),
 						((Value) entry.getValue()).getImmutableValue(visited));
 			else
 				inherits.put(entry.getKey(), entry.getValue());
 		}
 		return immutableValue;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2010 xored software, Inc.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* xored software, Inc. - initial API and Implementation (Alex Panchenko)
	*******************************************************************************/
	package org.eclipse.dltk.internal.javascript.ti;

	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.IdentityHashMap;
	import java.util.Map;
	import java.util.Set;
	import java.util.concurrent.atomic.AtomicBoolean;

	import org.eclipse.dltk.javascript.core.JavaScriptPlugin;
	import org.eclipse.dltk.javascript.core.Types;
	import org.eclipse.dltk.javascript.typeinference.IValueCollection;
	import org.eclipse.dltk.javascript.typeinference.IValueReference;
	import org.eclipse.dltk.javascript.typeinference.ReferenceKind;
	import org.eclipse.dltk.javascript.typeinference.ReferenceLocation;
	import org.eclipse.dltk.javascript.typeinfo.IRProperty;
	import org.eclipse.dltk.javascript.typeinfo.IRSimpleType;
	import org.eclipse.dltk.javascript.typeinfo.IRType;
	import org.eclipse.dltk.javascript.typeinfo.ITypeSystem;
	import org.eclipse.dltk.javascript.typeinfo.JSTypeSet;
	import org.eclipse.dltk.javascript.typeinfo.ReferenceSource;
	import org.eclipse.dltk.javascript.typeinfo.model.Type;

	public class Value extends ImmutableValue {

	public Value() {
	}

	public Value(ImmutableValue value) {
	super(value);
	}

	@Override
	public void setDeclaredType(IRType declaredType) {
	this.declaredType = declaredType;
	}

	@Override
	public void addType(IRType type) {
	if (type != null) {
	this.types.add(type);
	}
	}

	@Override
	public void setKind(ReferenceKind kind) {
	this.kind = kind;
	}

	@Override
	public void setLocation(ReferenceLocation location) {
	this.location = location;
	}

	@Override
	public void setAttribute(String key, Object value) {
	if (value != null) {
	if (attributes == null) {
	attributes = new HashMap<String, Object>();
	}
	attributes.put(key, value);
	} else {
	if (attributes != null) {
	attributes.remove(key);
	}
	}
	}

	@Override
	public void deleteChild(String name, boolean force) {
	if (force) {
	children.remove(name);
	inherited.remove(name);
	} else {
	if (deletedChildren == null) {
	deletedChildren = new HashSet<String>();
	}
	deletedChildren.add(name);
	}
	}

	@Override
	public void putChild(String name, IValue value) {
	inherited.put(name, value);
	}

	private static class CreateChildOperation implements Handler<Set<IValue>> {

	private final String childName;

	public CreateChildOperation(String childName) {
	this.childName = childName;
	}

	public void process(ImmutableValue value, Set<IValue> result) {
	if (result.isEmpty() && !value.hasReferences()) {
	IValue child = value.createChild(childName, 0);
	if (child != null)
	result.add(child);
	}
	}

	}

	@Override
	public IValue createChild(String name, int flags) {
	IValue child = children.get(name);
	if (child == null) {
	child = inherited.get(name);
	if (child == null) {
	if ((flags & CREATE) == 0) {
	// creating new child, so ignore external elements
	child = findMember(name, false);
	if (child != null) {
	return child;
	}
	}
	if (hasReferences()) {
	Set<IValue> result = new HashSet<IValue>();
	execute(this, new CreateChildOperation(name), result,
	new HashSet<IValue>());
	if (!result.isEmpty()) {
	return result.iterator().next();
	}
	}
	child = new Value();
	children.put(name, (Value) child);
	childCreated(name);
	}
	}
	return child;
	}

	@Override
	public void clear() {
	references.clear();
	children.clear();
	inherited.clear();
	types.clear();
	}

	@SuppressWarnings("serial")
	static class DeepValueRecursionException extends RuntimeException {
	}

	private static final ThreadLocal<AtomicBoolean> recursionErrorReported = new ThreadLocal<AtomicBoolean>() {
	@Override
	protected AtomicBoolean initialValue() {
	return new AtomicBoolean();
	}
	};

	@Override
	public void addValue(IValue src) {
	if (src instanceof ImmutableValue) {
	final IdentityHashMap<ImmutableValue, ImmutableValue> processing = new IdentityHashMap<ImmutableValue, ImmutableValue>();
	try {
	addValueRecursive((ImmutableValue) src, processing, 0);
	} catch (DeepValueRecursionException e) {
	e.printStackTrace();
	if (recursionErrorReported.get().compareAndSet(false, true)) {
	String msg = "Deep recursion while copying the value";
	final ReferenceSource source = ITypeSystem.CURRENT
	.getCurrentSource();
	if (source != null) {
	msg += " when processing " + source;
	}
	JavaScriptPlugin.error(msg, e);
	}
	}
	// translate references, so they point to the new value
	for (Map.Entry<ImmutableValue, ImmutableValue> entry : processing
	.entrySet()) {
	final ImmutableValue input = entry.getKey();
	final ImmutableValue output = entry.getValue();
	for (IValue ref : input.references) {
	IValue refOut = processing.get(ref);
	if (refOut == null) {
	refOut = ref;
	}
	output.references.add(refOut);
	}
	}
	} else {
	// ElementValue is handled in this branch.
	final IRType srcType = src.getDeclaredType();
	if (srcType != null) {
	types.add(srcType);
	}
	types.addAll(src.getTypes());
	if (src.getKind() == ReferenceKind.METHOD) {
	final Object element = src.getAttribute(
	IReferenceAttributes.ELEMENT, false);
	if (element != null) {
	setAttribute(IReferenceAttributes.ELEMENT, element);
	}
	final IValue returnType = src.getChild(
	IValueReference.FUNCTION_OP, false);
	if (returnType != null) {
	final JSTypeSet myReturnTypes = createChild(
	IValueReference.FUNCTION_OP, 0).getTypes();
	myReturnTypes.addAll(returnType.getTypes());
	myReturnTypes.addAll(returnType.getDeclaredTypes());
	}
	} else if (src.getKind() == ReferenceKind.PROPERTY
	&& !isPrimitiveValue(srcType)) {
	/*
	* to optimize memory usage remember *static non-primitive
	* properties* only
	*/
	final Object element = src.getAttribute(
	IReferenceAttributes.ELEMENT, false);
	if (element != null && element instanceof IRProperty
	&& ((IRProperty) element).isStatic()) {
	setAttribute(IReferenceAttributes.ELEMENT, element);
	}
	}
	}
	}

	private static boolean isPrimitiveValue(IRType type) {
	if (type instanceof IRSimpleType) {
	final Type target = ((IRSimpleType) type).getTarget();
	return target == Types.BOOLEAN \|\| target == Types.STRING
	\|\| target == Types.NUMBER;
	} else {
	return false;
	}
	}

	@Override
	public void addReference(IValue src) {
	assert src != null;
	if (src == this)
	return;
	references.add(src);
	}

	@Override
	public void removeReference(IValue value) {
	references.remove(value);
	}

	private void addValueRecursive(ImmutableValue src,
	Map<ImmutableValue, ImmutableValue> processing, int depth) {
	if (!processing.containsKey(src)) {
	processing.put(src, this);
	if (depth > 8) {
	throw new DeepValueRecursionException();
	}
	if (src.declaredType != null) {
	types.add(src.declaredType);
	} else {
	types.addAll(src.types);
	}
	// (references will be copied later)
	if (src.attributes != null) {
	if (attributes == null) {
	attributes = new HashMap<String, Object>();
	}
	attributes.putAll(src.attributes);
	}
	for (Map.Entry<String, ImmutableValue> entry : src.children
	.entrySet()) {
	IValue child = createChild(entry.getKey(), 0);
	if (child instanceof Value) {
	((Value) child).addValueRecursive(entry.getValue(),
	processing, depth + 1);
	}
	}
	if (src.kind != ReferenceKind.UNKNOWN
	&& kind == ReferenceKind.UNKNOWN) {
	kind = src.kind;
	}
	if (src.location != ReferenceLocation.UNKNOWN
	&& location == ReferenceLocation.UNKNOWN) {
	location = src.location;
	} else if (src.location != ReferenceLocation.UNKNOWN
	&& src.declaredType != null
	&& src.kind == ReferenceKind.FUNCTION) {
	// if src location is known and the src is a function, then we
	// need to remember the location if this function is used as a
	// local type (through the assignment)
	if (attributes == null) {
	attributes = new HashMap<String, Object>();
	}
	attributes.put(IReferenceAttributes.LOCAL_TYPE_LOCATION,
	src.location);
	}
	}
	}

	public void putDirectChild(String name, ImmutableValue value) {
	children.put(name, value);
	}

	public void copyChilds(ImmutableValue value) {
	if (value.hasReferences()) {
	execute(value, new Handler<Map<String, ImmutableValue>>() {
	public void process(ImmutableValue value,
	Map<String, ImmutableValue> result) {
	result.putAll(value.children);
	};
	}, this.children, new HashSet<IValue>());
	} else {
	this.children.putAll(value.children);
	}
	}

	public void resolveLazyValues(Set<Value> visited) {
	if (visited.add(this)) {
	for (IValue value : references) {
	if (value instanceof ILazyValue
	&& !((ILazyValue) value).isResolved()) {
	((ILazyValue) value).setFinalResolve();
	} else if (value instanceof Value) {
	((Value) value).resolveLazyValues(visited);
	}
	}
	for (ImmutableValue value : children.values()) {
	if (value instanceof Value)
	((Value) value).resolveLazyValues(visited);
	}

	if (attributes != null) {
	for (Object attibute : attributes.values()) {
	if (attibute instanceof IValueProvider) {
	IValue value = ((IValueProvider) attibute).getValue();
	if (value instanceof Value) {
	((Value) value).resolveLazyValues(visited);
	}
	}
	}
	}
	}
	}

	public ImmutableValue getImmutableValue(Map<Object, Object> visited) {
	ImmutableValue immutableValue = (ImmutableValue) visited.get(this);
	if (immutableValue != null)
	return immutableValue;

	if (this instanceof ILazyValue) {
	((ILazyValue) this).resolve();
	}

	JSTypeSet typeSet = JSTypeSet.create();
	typeSet.addAll(types);
	Set<String> deletedChilds = null;
	if (deletedChildren != null) {
	deletedChilds = new HashSet<String>(deletedChildren.size(), 0.9f);
	deletedChilds.addAll(deletedChildren);
	}

	Map<String, ImmutableValue> childs = new HashMap<String, ImmutableValue>(
	children.size(), 0.9f);
	Map<String, IValue> inherits = new HashMap<String, IValue>(
	inherited.size(), 0.9f);
	Set<IValue> refers = new HashSet<IValue>(references.size(), 0.9f);
	Map<String, Object> atts = null;
	if (attributes != null) {
	atts = new HashMap<String, Object>(attributes.size(), 0.9f);
	for (Map.Entry<String, Object> entry : attributes.entrySet()) {
	if (entry.getValue() instanceof Value) {
	atts.put(entry.getKey(), ((Value) entry.getValue())
	.getImmutableValue(visited));
	} else if (entry.getValue() instanceof IValueCollection) {
	atts.put(entry.getKey(), ImmutableValueCollection
	.getImmutableValueCollection(
	(IValueCollection) entry.getValue(),
	visited));

	} else {
	atts.put(entry.getKey(), entry.getValue());
	}
	}
	}
	immutableValue = new ImmutableValue(declaredType, typeSet,
	deletedChilds, kind, location, childs, inherits, refers, atts);
	visited.put(this, immutableValue);

	for (IValue value : references) {
	if (value instanceof Value) {
	refers.add(((Value) value).getImmutableValue(visited));
	} else {
	refers.add(value);
	}
	}

	for (Map.Entry<String, ImmutableValue> entry : children.entrySet()) {
	if (entry.getValue() instanceof Value) {
	childs.put(entry.getKey(),
	((Value) entry.getValue()).getImmutableValue(visited));
	} else {
	childs.put(entry.getKey(), entry.getValue());
	}
	}

	for (Map.Entry<String, IValue> entry : inherited.entrySet()) {
	if (entry.getValue() instanceof Value)
	inherits.put(entry.getKey(),
	((Value) entry.getValue()).getImmutableValue(visited));
	else
	inherits.put(entry.getKey(), entry.getValue());
	}
	return immutableValue;
	}

	}