org.eclipse.xtext.xbase.typesystem.computation.ITypeComputationState Java Examples

protected void _computeTypes(RichStringForLoop object, ITypeComputationState state) {
	LightweightTypeReference charSequence = getRawTypeForName(CharSequence.class, state);
	ITypeComputationState eachState = state.withExpectation(charSequence);
	JvmFormalParameter parameter = object.getDeclaredParam();
	if (parameter != null) {
		LightweightTypeReference parameterType = computeForLoopParameterType(object, state);
		eachState = eachState.assignType(parameter, parameterType);
	}
	eachState.computeTypes(object.getEachExpression());
	
	state.withNonVoidExpectation().computeTypes(object.getBefore());
	state.withNonVoidExpectation().computeTypes(object.getSeparator());
	state.withNonVoidExpectation().computeTypes(object.getAfter());
	
	LightweightTypeReference primitiveVoid = getPrimitiveVoid(state);
	state.acceptActualType(primitiveVoid);
	
	state.acceptActualType(charSequence);
}
 

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
	try {
		assertTrue("state is instanceof ExpressionTypeComputationState", (state instanceof ExpressionTypeComputationState));
		LightweightTypeReference expectedType = getFirst(state.getExpectations(), null).getExpectedType();
		if (expression instanceof XNullLiteral) {
			ExpressionTypeComputationState casted = ((ExpressionTypeComputationState) state);
			ResolvedTypes resolution = reflectExtensions.get(casted, "resolvedTypes");
			ResolvedTypes parentResolution = reflectExtensions
					.get(reflectExtensions.<ExpressionTypeComputationState> get(casted, "parent"), "resolvedTypes");
			assertNull(parentResolution.getActualType(((XExpression) ((XNullLiteral) expression).eContainer())));
			state.acceptActualType(expectedType);
			assertNull(parentResolution.getActualType(expression));
			assertEquals(expectedType.getIdentifier(), resolution.getActualType(expression).getIdentifier());
			assertNull(parentResolution.getActualType(((XExpression) ((XNullLiteral) expression).eContainer())));
		} else {
			assertTrue((expression instanceof XBlockExpression));
			XNullLiteral nullLiteral = ((XNullLiteral) getFirst(expression.eContents(), null));
			state.computeTypes(nullLiteral);
			ResolvedTypes res = reflectExtensions.get(state, "resolvedTypes");
			assertEquals(expectedType.getIdentifier(), res.getActualType(nullLiteral).getIdentifier());
		}
	} catch (IllegalAccessException | SecurityException | NoSuchFieldException | IllegalArgumentException e) {
		throw Exceptions.sneakyThrow(e);
	}
}
 

@Override
protected void resolveArgumentType(XExpression argument, /* @Nullable */ LightweightTypeReference declaredType, ITypeComputationState argumentState) {
	if (argument == getSyntacticReceiver()) {
		LightweightTypeReference receiverType = getSyntacticReceiverType();
		if (receiverType == null) {
			throw new IllegalStateException("Cannot determine the receiver's type");
		}
		resolveKnownArgumentType(argument, receiverType, declaredType, argumentState);
	} else if (argument == getImplicitFirstArgument()) {
		LightweightTypeReference argumentType = getImplicitFirstArgumentType();
		if (argumentType == null) {
			throw new IllegalStateException("Cannot determine the implicit argument's type");
		}
		resolveKnownArgumentType(argument, argumentType, declaredType, argumentState);
	} else {
		super.resolveArgumentType(argument, declaredType, argumentState);
	}
}
 

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
	if (expression instanceof AnonymousClass) {
		_computeTypes((AnonymousClass) expression, state);
	} else if (expression instanceof RichString) {
		_computeTypes((RichString)expression, state);
	} else if (expression instanceof RichStringForLoop) {
		_computeTypes((RichStringForLoop)expression, state);
	} else if (expression instanceof RichStringIf) {
		_computeTypes((RichStringIf)expression, state);
	} else if (expression instanceof RichStringLiteral) {
		_computeTypes((RichStringLiteral)expression, state);
	} else {
		super.computeTypes(expression, state);
	}
}
 

@Override
protected void resolveArgumentType(XExpression argument, /* @Nullable */ LightweightTypeReference declaredType, ITypeComputationState argumentState) {
	if (argument == getSyntacticReceiverIfPossibleArgument()) {
		LightweightTypeReference receiverType = getSyntacticReceiverType();
		if (receiverType != null) {
			resolveKnownArgumentType(argument, receiverType, declaredType, argumentState);
		}
	} else if (argument == getImplicitFirstArgument()) {
		LightweightTypeReference argumentType = getImplicitFirstArgumentType();
		if (argumentType != null) {
			resolveKnownArgumentType(argument, argumentType, declaredType, argumentState);
		}
	} else {
		super.resolveArgumentType(argument, declaredType, argumentState);
	}
}
 

protected void _computeTypes(RichStringIf object, ITypeComputationState state) {
	LightweightTypeReference charSequence = getRawTypeForName(CharSequence.class, state);
	LightweightTypeReference booleanType = getRawTypeForName(Boolean.TYPE, state);
	
	ITypeComputationState conditionExpectation = state.withExpectation(booleanType);
	XExpression condition = object.getIf();
	conditionExpectation.computeTypes(condition);
	XExpression thenExpression = object.getThen();
	ITypeComputationState thenState = reassignCheckedType(condition, thenExpression, state);
	thenState.withExpectation(charSequence).computeTypes(thenExpression);
	for(RichStringElseIf elseIf: object.getElseIfs()) {
		state.withExpectation(booleanType).computeTypes(elseIf.getIf());
		ITypeComputationState elseState = reassignCheckedType(elseIf.getIf(), elseIf.getThen(), state);
		elseState.withExpectation(charSequence).computeTypes(elseIf.getThen());
	}
	state.withExpectation(charSequence).computeTypes(object.getElse());
	state.acceptActualType(charSequence);
}
 

protected void _computeTypes(final QuantityLiteral assignment, ITypeComputationState state) {
    LightweightTypeReference qt = null;
    for (ITypeExpectation exp : state.getExpectations()) {
        if (exp.getExpectedType() == null) {
            continue;
        }

        if (exp.getExpectedType().isType(Number.class)) {
            qt = getRawTypeForName(Number.class, state);
        }
        if (exp.getExpectedType().isType(State.class)) {
            qt = getRawTypeForName(Number.class, state);
        }
        if (exp.getExpectedType().isType(Command.class)) {
            qt = getRawTypeForName(Number.class, state);
        }
    }
    if (qt == null) {
        qt = getRawTypeForName(QuantityType.class, state);
    }
    state.acceptActualType(qt);
}
 

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
	if (expression instanceof SarlBreakExpression) {
		_computeTypes((SarlBreakExpression) expression, state);
	} else if (expression instanceof SarlContinueExpression) {
		_computeTypes((SarlContinueExpression) expression, state);
	} else if (expression instanceof SarlAssertExpression) {
		_computeTypes((SarlAssertExpression) expression, state);
	} else if (expression instanceof SarlCastedExpression) {
		_computeTypes((SarlCastedExpression) expression, state);
	} else {
		try {
			super.computeTypes(expression, state);
		} catch (Throwable exception) {
			final Throwable cause = Throwables.getRootCause(exception);
			state.addDiagnostic(new EObjectDiagnosticImpl(
					Severity.ERROR,
					IssueCodes.INTERNAL_ERROR,
					cause.getLocalizedMessage(),
					expression,
					null,
					-1,
					null));
		}
	}
}
 

protected void _computeTypes(final QuantityLiteral assignment, ITypeComputationState state) {
    LightweightTypeReference qt = null;
    for (ITypeExpectation exp : state.getExpectations()) {
        if (exp.getExpectedType() == null) {
            continue;
        }

        if (exp.getExpectedType().isType(Number.class)) {
            qt = getRawTypeForName(Number.class, state);
        }
        if (exp.getExpectedType().isType(State.class)) {
            qt = getRawTypeForName(Number.class, state);
        }
        if (exp.getExpectedType().isType(Command.class)) {
            qt = getRawTypeForName(Number.class, state);
        }
    }
    if (qt == null) {
        qt = getRawTypeForName(QuantityType.class, state);
    }
    state.acceptActualType(qt);
}
 

protected void addExtensionProviders(ITypeComputationState state, List<JvmFormalParameter> parameters) {
	List<JvmFormalParameter> extensionProviders = null;
	for(JvmFormalParameter parameter: parameters) {
		if (isExtensionProvider(parameter)) {
			if (extensionProviders == null)
				extensionProviders = Lists.newLinkedList();
			extensionProviders.add(parameter);
		}
	}
	if (extensionProviders != null)
		state.addExtensionsToCurrentScope(extensionProviders);
}
 

@Override
public ITypeAssigner assignTypes() {
	final ITypeAssigner result = delegate.assignTypes();
	return new ITypeAssigner() {

		@Override
		public void assignType(JvmIdentifiableElement element, /* @Nullable */ LightweightTypeReference actualType) {
			result.assignType(element, actualType);
		}

		@Override
		public ITypeComputationState getForkedState() {
			return newForwardingTypeComputationState(result.getForkedState());
		}

		@Override
		public ITypeReferenceOwner getReferenceOwner() {
			return result.getReferenceOwner();
		}

		@Override
		public LightweightTypeReference toLightweightTypeReference(JvmTypeReference reference) {
			return result.toLightweightTypeReference(reference);
		}
		
	};
}
 

@Override
protected void capture(ITypeComputationState state) {
	this.capturedState = ((AbstractTypeComputationState) state).getFeatureScopeSession();
	IFeatureScopeSession nestedSession = typeResolver.addThisAndSuper(capturedState, state.getReferenceOwner(), localClass, getEquivalent(), true);
	
	ResolvedTypes capturedResolvedTypes = captureResolvedTypes(state);
	typeResolver.doPrepare(capturedResolvedTypes, nestedSession, localClass, resolvedTypesByContext);
}
 

@Override
public ITypeComputationState withoutExpectation() {
	AbstractTypeComputationState[] result = new AbstractTypeComputationState[components.length];
	for (int i = 0; i < components.length; i++) {
		result[i] = components[i].withoutExpectation();
	}
	return new CompoundTypeComputationState(owner, result);
}
 

protected void resolveKnownArgumentType(XExpression argument, LightweightTypeReference knownType,
		/* @Nullable */ LightweightTypeReference declaredType, ITypeComputationState argumentState) {
	if (!(argumentState instanceof AbstractLinkingCandidate.ArgumentTypeComputationState))
		throw new IllegalArgumentException("argumentState was " + argumentState);
	AbstractLinkingCandidate<?>.ArgumentTypeComputationState castedArgumentState = (AbstractLinkingCandidate<?>.ArgumentTypeComputationState) argumentState;
	ResolvedTypes resolvedTypes = getState().getResolvedTypes();
	LightweightTypeReference copiedDeclaredType = declaredType != null ? declaredType.copyInto(resolvedTypes.getReferenceOwner()) : null;
	TypeExpectation expectation = new TypeExpectation(copiedDeclaredType, castedArgumentState, false);
	LightweightTypeReference copiedReceiverType = knownType.copyInto(resolvedTypes.getReferenceOwner());
	// TODO should we use the result of #acceptType?
	int defaultFlags = castedArgumentState.getDefaultFlags();
	resolvedTypes.acceptType(argument, expectation, copiedReceiverType, false, ConformanceFlags.UNCHECKED | defaultFlags);
	if (copiedDeclaredType != null)
		resolveAgainstActualType(copiedDeclaredType, copiedReceiverType, castedArgumentState);
}
 

public static void captureLocalVariables(JvmTypeReference typeReference, ITypeComputationState state) {
	LocalVariableCapturer localClassSupertype = findLocalClassSupertype(typeReference);
	if (localClassSupertype != null) {
		if (!localClassSupertype.captured) {
			localClassSupertype.captured = true;
			localClassSupertype.capture(state);
		}
		return;
	}
	throw new IllegalStateException("Unexpected typeReference: " + typeReference);
}
 

protected void resolveKnownArgumentType(XExpression argument, LightweightTypeReference knownType,
		/* @Nullable */ LightweightTypeReference declaredType, ITypeComputationState argumentState) {
	if (!(argumentState instanceof AbstractTypeComputationState))
		throw new IllegalArgumentException("argumentState was " + argumentState);
	AbstractTypeComputationState castedArgumentState = (AbstractTypeComputationState) argumentState;
	ResolvedTypes resolvedTypes = getState().getResolvedTypes();
	LightweightTypeReference copiedDeclaredType = declaredType != null ? declaredType.copyInto(resolvedTypes.getReferenceOwner()) : null;
	TypeExpectation expectation = new TypeExpectation(copiedDeclaredType, castedArgumentState, false);
	LightweightTypeReference copiedReceiverType = knownType.copyInto(resolvedTypes.getReferenceOwner());
	// TODO should we use the result of #acceptType?
	resolvedTypes.acceptType(argument, expectation, copiedReceiverType, false, ConformanceFlags.UNCHECKED);
	if (copiedDeclaredType != null)
		resolveAgainstActualType(copiedDeclaredType, copiedReceiverType, castedArgumentState);
}
 

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
	if (expression instanceof XAnnotation) {
		_computeTypes((XAnnotation)expression, state);
	} else {
		super.computeTypes(expression, state);
	}
}
 

protected void computeChildTypesForUnknownAnnotation(XAnnotation object, ITypeComputationState state) {
	XExpression expression = object.getValue();
	if (expression != null)
		state.withNonVoidExpectation().computeTypes(expression);
	else {
		List<XAnnotationElementValuePair> valuePairs = object.getElementValuePairs();
		for(XAnnotationElementValuePair pair: valuePairs) {
			computeTypes(object, pair.getElement(), pair.getValue(), state);
		}
	}
}
 

private ITypeComputationState addEnumImportsIfNecessary(ITypeComputationState state, LightweightTypeReference expectedType, JvmType enumTypeCandidate) {
	ITypeComputationState expectationState = state.withExpectation(expectedType);
	if (enumTypeCandidate != null && enumTypeCandidate.eClass() == TypesPackage.Literals.JVM_ENUMERATION_TYPE) {
		expectationState.addImports(new EnumLiteralImporter((JvmDeclaredType) enumTypeCandidate));
	}
	return expectationState;
}
 

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
	if (predicate.apply(expression).booleanValue()) {
		test.recordExpectation(expression, state);
	}
	super.computeTypes(expression, state);
}
 

public void recordExpectation(final XExpression expression, final ITypeComputationState state) {
  List<? extends ITypeExpectation> _expectations = state.getExpectations();
  Iterables.<ITypeExpectation>addAll(this.finalExpectations, _expectations);
  final Function1<ITypeExpectation, String> _function = (ITypeExpectation it) -> {
    LightweightTypeReference _expectedType = it.getExpectedType();
    String _simpleName = null;
    if (_expectedType!=null) {
      _simpleName=_expectedType.getSimpleName();
    }
    return _simpleName;
  };
  List<String> _map = ListExtensions.map(state.getExpectations(), _function);
  Iterables.<String>addAll(this.expectations, _map);
  this.expressions.add(expression);
}
 

@Override
protected ClosureWithExpectationHelper createClosureWithExpectationHelper(JvmOperation operation) {
	return new ClosureWithExpectationHelper(getClosure(), operation, getExpectation(), getState()) {
		@Override
		protected ITypeComputationState assignParameters(ITypeAssigner typeAssigner) {
			ITypeComputationState result = super.assignParameters(typeAssigner);
			addExtensions(result);
			return result;
		}
	};
}
 

@Override
protected UnknownClosureTypeHelper createUnknownClosureTypeHelper() {
	return new UnknownClosureTypeHelper(getClosure(), getExpectation(), getState()) {
		@Override
		protected ITypeComputationState assignParameters(ITypeAssigner typeAssigner) {
			ITypeComputationState result = super.assignParameters(typeAssigner);
			addExtensions(result);
			return result;
		}
	};
}
 

@Override
protected ClosureWithoutExpectationHelper createClosureWithoutExpectationHelper() {
	return new ClosureWithoutExpectationHelper(getClosure(), getExpectation(), getState()) {
		@Override
		protected ITypeComputationState assignParameters(ITypeAssigner typeAssigner,
				FunctionTypeReference incompleteClosureType) {
			ITypeComputationState result = super.assignParameters(typeAssigner, incompleteClosureType);
			addExtensions(result);
			return result;
		}
	};
}
 

protected void addExtensions(ITypeComputationState state) {
	List<JvmFormalParameter> extensionProviders = null;
	for(JvmFormalParameter parameter: getClosure().getDeclaredFormalParameters()) {
		if (parameter instanceof XtendFormalParameter && ((XtendFormalParameter) parameter).isExtension()) {
			if (extensionProviders == null)
				extensionProviders = Lists.newLinkedList();
			extensionProviders.add(parameter);
		}
	}
	if (extensionProviders != null)
		state.addExtensionsToCurrentScope(extensionProviders);
}
 

protected void _computeTypes(AnonymousClass anonymousClass, ITypeComputationState state) {
	JvmGenericType type = associations.getInferredType(anonymousClass);
	if (type != null) {
		// should never be null but the associations don't promise anything
		LocalVariableCapturer.captureLocalVariables(type, state);
	}
	state.computeTypes(anonymousClass.getConstructorCall());
}
 

@Override
protected void addLocalToCurrentScope(XVariableDeclaration localVariable, ITypeComputationState state) {
	super.addLocalToCurrentScope(localVariable, state);
	if (localVariable instanceof XtendVariableDeclaration && ((XtendVariableDeclaration) localVariable).isExtension()) {
		state.addExtensionToCurrentScope(localVariable);
		state.rewriteScope(localVariable);
	}
}
 

@Override
protected ITypeComputationState assignType(JvmFormalParameter param, /* @Nullable */ LightweightTypeReference type,
		ITypeComputationState state) {
	ITypeComputationState result = super.assignType(param, type, state);
	if (param instanceof XtendFormalParameter && ((XtendFormalParameter) param).isExtension()) {
		result.addExtensionToCurrentScope(param);
	}
	return result;
}
 

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
    if (expression instanceof QuantityLiteral) {
        _computeTypes((QuantityLiteral) expression, state);
    } else {
        super.computeTypes(expression, state);
    }
}
 

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
    if (expression instanceof QuantityLiteral) {
        _computeTypes((QuantityLiteral) expression, state);
    } else {
        super.computeTypes(expression, state);
    }
}