org.eclipse.xtext.common.types.access.TypeResource Java Examples

/**
 * Registers the given listener to be notified on type changes, if (and only if) the type
 * if expected to be changeable.
 * 
 * @see IMirrorExtension#isSealed()
 */
protected static void requestNotificationOnChange(JvmType type, Runnable listener) {
	Resource resource = type.eResource();
	if (resource instanceof TypeResource) {
		IMirror mirror = ((TypeResource) resource).getMirror();
		if (mirror instanceof IMirrorExtension) {
			if (((IMirrorExtension) mirror).isSealed())
				return;
		}
	}
	Notifier notifier = type;
	if (resource != null) {
		if (resource.getResourceSet() != null)
			notifier = resource.getResourceSet();
		else
			notifier = resource;
	}
	JvmTypeChangeDispatcher dispatcher = JvmTypeChangeDispatcher.findResourceChangeDispatcher(notifier);
	dispatcher.requestNotificationOnChange(type, listener);
}
 

/**
 * @since 2.7
 */
@Override
public JvmDeclaredType createType(IType type, TypeResource resource, Map<?, ?> options) {
	if (resource == null) {
		return createType(type);
	}
	if (options != null) {
		IJavaProject javaProject = (IJavaProject) options.get(TypeResource.OPTION_CLASSPATH_CONTEXT);
		if (javaProject != null) {
			return createType(type, javaProject);
		}
	}
	ResourceSet resourceSet = resource.getResourceSet();
	if (resourceSet instanceof XtextResourceSet) {
		Object project = ((XtextResourceSet) resourceSet).getClasspathURIContext();
		if (project instanceof IJavaProject) {
			return createType(type, (IJavaProject) project);
		}
	}
	return createType(type);
}
 

/**
 * @since 2.7
 */
@Override
public void initialize(TypeResource typeResource, Map<?, ?> options) {
	try {
		if (typeFactory instanceof ITypeFactory.OptionsAware<?, ?>) {
			JvmDeclaredType jvmType = ((ITypeFactory.OptionsAware<IType, JvmDeclaredType>) typeFactory).createType(mirroredType, typeResource, options);
			typeResource.getContents().add(jvmType);
		} else {
			typeResource.getContents().add(typeFactory.createType(mirroredType));
		}
	} catch (RuntimeException e) {
		if (typeResourceServices != null) {
			typeResourceServices.getOperationCanceledManager().propagateAsErrorIfCancelException(e);
		}
		LOG.error("Error initializing type "+typeResource.getURI(), e);
		throw e;
	}
	this.typeResource = typeResource;
}
 

private JvmType findTypeBySignature(String signature, TypeResource resource, boolean traverseNestedTypes) {
	// TODO: Maybe iterate the resource without computing a fragment
	String fragment = typeUriHelper.getFragment(signature);
	JvmType result = (JvmType) resource.getEObject(fragment);
	if (result != null || !traverseNestedTypes)
		return result;
	List<EObject> contents = resource.getContents();
	if (contents.isEmpty()) {
		return null;
	}
	String rootTypeName = resource.getURI().segment(1);
	String nestedTypeName = fragment.substring(rootTypeName.length() + 1);
	List<String> segments = Strings.split(nestedTypeName, "$");
	EObject rootType = contents.get(0);
	if (rootType instanceof JvmDeclaredType) {
		result = findNestedType((JvmDeclaredType) rootType, segments, 0);
	}
	return result;
}
 

private JvmType findTypeByClass(BinaryClass clazz) {
	try {
		IndexedJvmTypeAccess indexedJvmTypeAccess = getIndexedJvmTypeAccess();
		URI resourceURI = clazz.getResourceURI();
		if (indexedJvmTypeAccess != null) {
			URI proxyURI = resourceURI.appendFragment(clazz.getURIFragment());
			EObject candidate = indexedJvmTypeAccess.getIndexedJvmType(proxyURI, getResourceSet());
			if (candidate instanceof JvmType)
				return (JvmType) candidate;
		}
		TypeResource result = (TypeResource) getResourceSet().getResource(resourceURI, true);
		return findTypeByClass(clazz, result);
	} catch(UnknownNestedTypeException e) {
		return null;
	}
}
 

private boolean canLink(JvmType type) {
	Resource resource = type.eResource();
	if (resource instanceof TypeResource) {
		IMirror mirror = ((TypeResource) resource).getMirror();
		if (mirror instanceof JdtTypeMirror) {
			try {
				return canLink(((JdtTypeMirror) mirror).getMirroredType());
			} catch (JavaModelException e) {
				return false;
			}
		} else {
			return true;
		}
	}
	URI resourceURI = resource.getURI();
	if (resourceURI.isPlatformResource() && resourceURI.segment(1).equals(javaProject.getProject().getName())) {
		IndexedJvmTypeAccess indexedJvmTypeAccess = this.getIndexedJvmTypeAccess();
		if (indexedJvmTypeAccess != null && indexedJvmTypeAccess.isIndexingPhase(getResourceSet())) {
			return false;
		}
	}
	return true;
}
 

protected void requestNotificationOnChange(Runnable listener) {
	Resource resource = eResource();
	if (resource instanceof TypeResource) {
		IMirror mirror = ((TypeResource) resource).getMirror();
		if (mirror instanceof IMirrorExtension) {
			if (((IMirrorExtension) mirror).isSealed())
				return;
		}
	}
	Notifier notifier = this;
	if (resource != null) {
		if (resource.getResourceSet() != null)
			notifier = resource.getResourceSet();
		else
			notifier = resource;
	}
	JvmTypeChangeDispatcher dispatcher = JvmTypeChangeDispatcher.findResourceChangeDispatcher(notifier);
	dispatcher.requestNotificationOnChange(this, listener);
}
 

@Override
public TypeResource createResource(URI uri) {
	TypeResource result = doCreateResource(uri);
	final IMirror createMirror = createMirror(uri);
	if (createMirror !=  null) 
		result.setMirror(createMirror);
	return result;
}
 

protected Object evaluateField(final XAbstractFeatureCall call, final JvmField field, final Context context) {
  if ((field.isSetConstant() || (field.eResource() instanceof TypeResource))) {
    boolean _isConstant = field.isConstant();
    if (_isConstant) {
      return field.getConstantValue();
    } else {
      String _simpleName = field.getDeclaringType().getSimpleName();
      String _plus = ("Field " + _simpleName);
      String _plus_1 = (_plus + ".");
      String _simpleName_1 = field.getSimpleName();
      String _plus_2 = (_plus_1 + _simpleName_1);
      String _plus_3 = (_plus_2 + " is not a constant");
      throw new ConstantExpressionEvaluationException(_plus_3);
    }
  }
  final XExpression expression = this.containerProvider.getAssociatedExpression(field);
  boolean _contains = context.getAlreadyEvaluating().contains(expression);
  if (_contains) {
    throw new ConstantExpressionEvaluationException("Endless recursive evaluation detected.");
  }
  try {
    final Map<String, JvmIdentifiableElement> visibleFeatures = this.findVisibleFeatures(expression);
    JvmTypeReference _type = field.getType();
    ClassFinder _classFinder = context.getClassFinder();
    Set<XExpression> _alreadyEvaluating = context.getAlreadyEvaluating();
    final Context ctx = new Context(_type, _classFinder, visibleFeatures, _alreadyEvaluating);
    return this.evaluate(expression, ctx);
  } catch (final Throwable _t) {
    if (_t instanceof ConstantExpressionEvaluationException) {
      final ConstantExpressionEvaluationException e = (ConstantExpressionEvaluationException)_t;
      throw new StackedConstantExpressionEvaluationException(call, field, e);
    } else {
      throw Exceptions.sneakyThrow(_t);
    }
  }
}
 

@Override
public TypeResource createResource(URI uri) {
	String qualifiedName = uri.lastSegment();
	if (qualifiedName.lastIndexOf('$') != -1) {
		String outermostClassName = new BinaryClass(qualifiedName, classLoader).getOutermostClassName();
		return super.createResource(URIHelperConstants.OBJECTS_URI.appendSegment(outermostClassName));
	}
	return super.createResource(uri);
}
 

public String getHash(final JvmDeclaredType type) {
	if(type.eResource() instanceof TypeResource) {
		IMirror mirror = ((TypeResource)type.eResource()).getMirror();
		if(mirror instanceof IMirrorExtension && ((IMirrorExtension) mirror).isSealed())
			return type.getIdentifier();
	}
	return cache.get(Tuples.create(HASH_CACHE_KEY, type), type.eResource(), new Provider<String>() {
		@Override
		public String get() {
			return signatureBuilderProvider.get().appendSignature(type).hash();
		}
	});
}
 

@Test public void testCreateResource_01() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = typeProvider.createResource(primitivesURI);
	assertNotNull(resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}
 

@Test public void testCreateResource_02() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = (TypeResource) resourceSet.createResource(primitivesURI);
	assertNotNull(resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}
 

@Test public void testGetResource_01() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = (TypeResource) resourceSet.getResource(primitivesURI, true);
	assertNotNull(resource);
	assertTrue(resource.isLoaded());
	assertEquals(9, resource.getContents().size());
}
 

@Test public void testGetResource_03() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource createdResource = (TypeResource) resourceSet.createResource(primitivesURI);
	TypeResource resource = (TypeResource) resourceSet.getResource(primitivesURI, false);
	assertSame(createdResource, resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}
 

@Test public void testGetResource_04() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource createdResource = (TypeResource) resourceSet.createResource(primitivesURI);
	TypeResource resource = (TypeResource) resourceSet.getResource(primitivesURI, true);
	assertSame(createdResource, resource);
	assertTrue(resource.isLoaded());
	assertEquals(9, resource.getContents().size());
}
 

@Override
protected void openEObject(EObject state) {
	try {
		if (state instanceof JvmIdentifiableElement && state.eResource() instanceof TypeResource) {
			IJavaElement javaElement = javaElementFinder.findElementFor((JvmIdentifiableElement) state);
			if (javaElement instanceof IMember) {
				IResource resource = javaElement.getResource();
				if (resource instanceof IStorage) {
					ITrace traceToSource = traceInformation.getTraceToSource((IStorage) resource);
					if (traceToSource != null) {
						ISourceRange sourceRange = ((IMember) javaElement).getSourceRange();
						ILocationInResource sourceInformation = traceToSource.getBestAssociatedLocation(new TextRegion(sourceRange.getOffset(), sourceRange.getLength()));
						if (sourceInformation != null) {
							globalURIEditorOpener.open(sourceInformation.getAbsoluteResourceURI().getURI(), javaElement, true);
							return;
						}
					}
				}
				globalURIEditorOpener.open(null, javaElement, true);
				return;
			}
		}
	} catch (Exception exc) {
		LOG.error("Error opening java editor", exc);
	}
	super.openEObject(state);
}
 

private boolean isValidationDisabled(EObject objectToView) {
	Resource resource = objectToView.eResource();
	if (resource instanceof XtextResource)
		return ((XtextResource)resource).isValidationDisabled();
	// If this is not done links to native java types can be navigated in the hover
	if(resource instanceof TypeResource)
		return false;
	return true; 
}
 

private JvmType findLoadedOrDerivedObjectType(/* @NonNull */ String signature, /* @NonNull */ URI resourceURI,
		/* @Nullable */ TypeResource resource, boolean traverseNestedTypes) throws UnknownNestedTypeException {
	JvmType result = resource != null ? findTypeBySignature(signature, resource, traverseNestedTypes) : null;
	if (result != null) {
		return result;
	}
	result = findObjectTypeInIndex(signature, resourceURI);
	if (result != null) {
		return result;
	}
	return null;
}
 

private TypeResource createResource(URI resourceURI, IType type) {
	TypeResource resource = doCreateResource(resourceURI);
	getResourceSet().getResources().add(resource);
	if (type.exists()) {
		IMirror mirror = createMirror(type);
		resource.setMirror(mirror);
	}
	return resource;
}
 

/**
 * Similar to {@link #linkedName(IStringExpectation, ICrossEReferenceAndEObject)} but concatenating the fully
 * qualified name again instead of using the qualified name provider, as the latter may not create a valid name for
 * non-globally available elements.
 * <p>
 * The qualified name created by retrieving all "name" properties of the target and its containers, using '/' as
 * separator.
 */
@Xpect
@ParameterParser(syntax = "('at' arg1=OFFSET)?")
public void linkedPathname(@StringExpectation IStringExpectation expectation,
		ICrossEReferenceAndEObject arg1) {
	EObject targetObject = (EObject) arg1.getEObject().eGet(arg1.getCrossEReference());
	if (targetObject == null) {
		Assert.fail("Reference is null");
		return; // to avoid warnings in the following
	}
	if (targetObject.eIsProxy())
		Assert.fail("Reference is a Proxy: " + ((InternalEObject) targetObject).eProxyURI());
	Resource targetResource = targetObject.eResource();
	if (targetResource instanceof TypeResource)
		targetResource = arg1.getEObject().eResource();
	if (!(targetResource instanceof XtextResource))
		Assert.fail("Referenced EObject is not in an XtextResource.");

	Deque<String> segments = new ArrayDeque<>();
	do {
		EStructuralFeature nameFeature = targetObject.eClass().getEStructuralFeature("name");
		if (nameFeature != null) {
			Object obj = targetObject.eGet(nameFeature);
			if (obj instanceof String) {
				segments.push((String) obj);
			}
		} else {
			if (targetObject instanceof NamedElement) {
				segments.push(((NamedElement) targetObject).getName());
			}
		}
		targetObject = targetObject.eContainer();
	} while (targetObject != null);
	String pathname = Joiner.on('/').join(segments);
	expectation.assertEquals(pathname);
}
 

@Override
public void initialize(TypeResource typeResource) {
	for(Class<?> primitiveClass: Primitives.ALL_PRIMITIVE_TYPES) {
		JvmType type = typeFactory.createType(primitiveClass);
		typeResource.getContents().add(type);
	}
}
 

@Test
public void testCreateResource_01() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = getTypeProvider().createResource(primitivesURI);
	assertNotNull(resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}
 

@Test
public void testCreateResource_02() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = (TypeResource) resourceSet.createResource(primitivesURI);
	assertNotNull(resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}
 

@Test
public void testGetResource_01() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = (TypeResource) resourceSet.getResource(primitivesURI, true);
	assertNotNull(resource);
	assertTrue(resource.isLoaded());
	assertEquals(9, resource.getContents().size());
}
 

@Test
public void testGetResource_03() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource createdResource = (TypeResource) resourceSet.createResource(primitivesURI);
	TypeResource resource = (TypeResource) resourceSet.getResource(primitivesURI, false);
	assertSame(createdResource, resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}
 

@Test
public void testGetResource_04() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource createdResource = (TypeResource) resourceSet.createResource(primitivesURI);
	TypeResource resource = (TypeResource) resourceSet.getResource(primitivesURI, true);
	assertSame(createdResource, resource);
	assertTrue(resource.isLoaded());
	assertEquals(9, resource.getContents().size());
}
 

@Before
public void setUp() throws Exception {
	callCount = 0;
	helper = new PrimitiveTypeFactory();
	mirror = new PrimitiveMirror(this);
	resource = new TypeResource();
	resource.setMirror(mirror);
}
 

@Test
public void testCreateResource_01() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = getTypeProvider().createResource(primitivesURI);
	assertNotNull(resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}
 

@Test
public void testCreateResource_02() {
	URI primitivesURI = URI.createURI("java:/Primitives");
	TypeResource resource = (TypeResource) resourceSet.createResource(primitivesURI);
	assertNotNull(resource);
	assertFalse(resource.isLoaded());
	assertTrue(resource.getContents().isEmpty());
}