protected TypeReferences getTypeReferences() { return reentrantTypeResolver.getServices().getTypeReferences(); }
protected Object getDefaultObjectValue(LightweightTypeReference type) { if(!type.isPrimitive()) return null; else { JvmPrimitiveType primitive = (JvmPrimitiveType) type.getType(); switch (services.getPrimitives().primitiveKind(primitive)) { case Byte : return Byte.valueOf((byte)0); case Short : return Short.valueOf((short)0); case Char : return Character.valueOf((char)0); case Int : return Integer.valueOf(0); case Long : return Long.valueOf(0l); case Float : return Float.valueOf(0f); case Double : return Double.valueOf("0."); case Boolean : return Boolean.FALSE; case Void : return null; default : throw new IllegalArgumentException("Not a primitive : "+primitive); } } }
/** * Computes the common super type for the given list of types. The list may not be empty. */ protected LightweightTypeReference getCommonSuperType(List<LightweightTypeReference> types, ITypeReferenceOwner owner) { return services.getTypeConformanceComputer().getCommonSuperType(types, owner); }
protected JvmTypeReference toJavaCompliantTypeReference(List<LightweightTypeReference> types, IVisibilityHelper visibilityHelper) { LightweightTypeReference type = getServices().getTypeConformanceComputer().getCommonSuperType(types, getOwner()); if (type == null) { return getOwner().getServices().getTypeReferences().getTypeForName(Object.class, getOwner().getContextResourceSet()); } return type.toJavaCompliantTypeReference(visibilityHelper); }
protected void requestCapturedLocalVariables(JvmTypeReference toBeWrapped, JvmDeclaredType type, ResolvedTypes resolvedTypes, Map<JvmIdentifiableElement, ResolvedTypes> resolvedTypesByContext, IAcceptor<JvmTypeReference> result) { LocalVariableCapturerImpl capturer = new LocalVariableCapturerImpl(toBeWrapped, type, this, resolvedTypes, resolvedTypesByContext); XComputedTypeReference ref = getServices().getXtypeFactory().createXComputedTypeReference(); ref.setTypeProvider(capturer); result.accept(ref); capturer.awaitCapturing(); } }
XBinaryOperation binaryOperation = (XBinaryOperation) featureCall; CommonTypeComputationServices services = getState().getReferenceOwner().getServices(); OperatorMapping operatorMapping = services.getOperatorMapping(); if (operatorMapping.getCompoundOperators().contains(description.getName())) { JvmIdentifiableElement feature = description.getElementOrProxy(); String methodName = feature.getSimpleName(); if (operatorMapping.isCompoundMethod(methodName)) { XExpressionHelper expressionHelper = services.getExpressionHelper(); if (expressionHelper.findReassignFirstArgumentAnnotation(feature) != null) { binaryOperation.setReassignFirstArgument(true);
protected TypesFactory getTypesFactory() { return getOwner().getServices().getTypesFactory(); }
&& !this.services.getExpressionHelper().hasSideEffects(source.getExpression())) { addAnnotationSafe(bodyOperation, Pure.class);
@Override public List<LightweightTypeReference> getThrownExceptions(XExpression obj) { return getServices().getEarlyExitComputer().getThrownExceptions(obj, this, this.getReferenceOwner()); }
protected BoundTypeArgumentMerger getTypeArgumentMerger() { return services.getBoundTypeArgumentMerger(); }
@Override public LightweightTypeReference tryConvertToListType() { ArrayTypes arrayTypes = getServices().getArrayTypes(); return arrayTypes.convertToList(this); }
TypeConformanceComputer conformanceComputer = typeResolver.getServices().getTypeConformanceComputer(); List<LightweightTypeReference> parameterTypes = Lists.newArrayListWithCapacity(cases.size()); JvmOperation inheritedDispatcher = null; if (inheritedParameterType != null) return typeResolver.toJavaCompliantTypeReference(inheritedParameterType, session); return typeResolver.getServices().getTypeReferences().getTypeForName(Object.class, operation);
@Override public JvmTypeReference toTypeReference() { if (internalGetResolvedTo() != null) { return resolvedTo.toTypeReference(); } XComputedTypeReference result = getServices().getXtypeFactory().createXComputedTypeReference(); result.setTypeProvider(new UnboundTypeReferenceResolver(this)); return result; }
/** Create an annotation with classes as values. * * @param type the type of the annotation. * @param values the values. * @return the reference to the JVM annotation. */ private JvmAnnotationReference annotationClassRef(Class<? extends Annotation> type, List<? extends JvmTypeReference> values) { try { final JvmAnnotationReference annot = this._annotationTypesBuilder.annotationRef(type); final JvmTypeAnnotationValue annotationValue = this.services.getTypesFactory().createJvmTypeAnnotationValue(); for (final JvmTypeReference value : values) { annotationValue.getValues().add(this.typeBuilder.cloneWithProxies(value)); } annot.getExplicitValues().add(annotationValue); return annot; } catch (IllegalArgumentException exception) { // ignore } return null; }
/** * Returns <code>true</code> for expressions that seem to be early exit expressions, e.g. * <pre> * while(condition) { * if (anotherCondition) * return value * changeResultOfFirstCondition * } * </pre> */ protected boolean isIntentionalEarlyExit(/* @Nullable */ XExpression expression) { ExtendedEarlyExitComputer earlyExitComputer = getReferenceOwner().getServices().getEarlyExitComputer(); return earlyExitComputer.isIntentionalEarlyExit(expression); }
protected boolean canResolveTo(LightweightTypeReference reference, List<LightweightBoundTypeArgument> allHints) { List<LightweightBoundTypeArgument> inferredHints = Lists.newArrayListWithCapacity(allHints.size()); List<LightweightBoundTypeArgument> effectiveHints = Lists.newArrayListWithCapacity(allHints.size()); EnumSet<VarianceInfo> varianceHints = EnumSet.noneOf(VarianceInfo.class); for(LightweightBoundTypeArgument hint: allHints) { if (hint.getOrigin() instanceof VarianceInfo) { varianceHints.add((VarianceInfo) hint.getOrigin()); } else { effectiveHints.add(hint); if (hint.getSource() == BoundTypeArgumentSource.INFERRED) { inferredHints.add(hint); } } } if (effectiveHints.isEmpty()) return false; boolean result = getServices().getBoundTypeArgumentMerger().isPossibleMergeResult(!inferredHints.isEmpty() ? inferredHints : effectiveHints, reference); return result; }
/** * {@inheritDoc} * * @see ArrayTypes#tryConvertToArray(ParameterizedTypeReference) */ @Override /* @Nullable */ public ArrayTypeReference tryConvertToArray() { ArrayTypes arrayTypes = getServices().getArrayTypes(); return arrayTypes.tryConvertToArray(this); }
protected <Type extends JvmType> Type findDeclaredType(Class<?> clazz, ITypeReferenceOwner owner) { @SuppressWarnings("unchecked") Type result = (Type) services.getTypeReferences().findDeclaredType(clazz, owner.getContextResourceSet()); return result; }
protected boolean isJavaConformant(LightweightTypeReference left, LightweightTypeReference right) { boolean result = (services.getTypeConformanceComputer().isConformant( left, right, RawTypeConformanceComputer.ALLOW_PRIMITIVE_WIDENING | RawTypeConformanceComputer.ALLOW_RAW_TYPE_CONVERSION | RawTypeConformanceComputer.ALLOW_BOXING | RawTypeConformanceComputer.ALLOW_UNBOXING) & RawTypeConformanceComputer.SUCCESS) != 0; return result; }
@Override public JvmTypeReference toTypeReference() { XFunctionTypeRef result = getOwner().getServices().getXtypeFactory().createXFunctionTypeRef(); result.setType(getType()); result.setEquivalent(getEquivalentTypeReference()); if (parameterTypes != null) { for(LightweightTypeReference parameterType: parameterTypes) { result.getParamTypes().add(parameterType.toTypeReference()); } } if (returnType != null) { result.setReturnType(returnType.toTypeReference()); } return result; }