Java XBlockExpression.getExpressions方法代码示例

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
/**
 * On Java-level the any-type is represented as java.lang.Object as there is no subtype of everything (i.e. type for null).
 * So, when the values are used we need to manually cast them to whatever is expected.
 * 
 *  This method tells us whether such a cast is needed.
 */
private boolean isToBeCastedAnyType(LightweightTypeReference actualType, XExpression obj, ITreeAppendable appendable) {
	if (actualType instanceof AnyTypeReference) {
		if (getReferenceName(obj, appendable) != null)
			return true;
		else if (obj instanceof XBlockExpression) {
			XBlockExpression blockExpression = (XBlockExpression) obj;
			EList<XExpression> expressions = blockExpression.getExpressions();
			if (expressions.isEmpty())
				return false;
			if (expressions.size() > 1)
				return true;
			XExpression last = expressions.get(0);
			return isToBeCastedAnyType(actualType, last, appendable);
		}
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
protected boolean bracesAreAddedByOuterStructure(XExpression expression) {
	EObject container = expression.eContainer();
	if (container instanceof XTryCatchFinallyExpression 
			|| container instanceof XIfExpression
			|| container instanceof XClosure
			|| container instanceof XSynchronizedExpression) {
		return true;
	}
	if (container instanceof XBlockExpression) {
		XBlockExpression blockExpression = (XBlockExpression) container;
		EList<XExpression> expressions = blockExpression.getExpressions();
		if (expressions.size() == 1 && expressions.get(0) == expression) {
			return bracesAreAddedByOuterStructure(blockExpression);
		}
	}
	if (!(container instanceof XExpression)) {
		return true;
	}
	return false;
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
protected void compileWithJvmConstructorCall(XBlockExpression obj, ITreeAppendable apendable) {
	EList<XExpression> expressions = obj.getExpressions();
	internalToJavaStatement(expressions.get(0), apendable.trace(obj, false), false);
	if (expressions.size() == 1) {
		return;
	}
	
	apendable.newLine().append("try {").increaseIndentation();
	
	ITreeAppendable b = apendable.trace(obj, false);
	for (int i = 1; i < expressions.size(); i++) {
		XExpression ex = expressions.get(i);
		internalToJavaStatement(ex, b, false);
	}
	
	generateCheckedExceptionHandling(apendable);
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
protected boolean hasJvmConstructorCall(XExpression obj) {
	if (!(obj instanceof XBlockExpression)) {
		return false;
	}
	XBlockExpression blockExpression = (XBlockExpression) obj;
	EList<XExpression> expressions = blockExpression.getExpressions();
	if (expressions.isEmpty()) {
		return false;
	}
	XExpression expr = expressions.get(0);
	if (!(expr instanceof XFeatureCall)) {
		return false;
	}
	XFeatureCall featureCall = (XFeatureCall) expr;
	return featureCall.getFeature() instanceof JvmConstructor;
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
@Override
protected void _format(final XBlockExpression xBlockExpression, @Extension final IFormattableDocument document) {
  final Consumer<ISemanticRegion> _function = (ISemanticRegion it) -> {
    final Procedure1<IHiddenRegionFormatter> _function_1 = (IHiddenRegionFormatter it_1) -> {
      it_1.newLine();
    };
    document.append(it, _function_1);
  };
  this.textRegionExtensions.regionFor(xBlockExpression).keywords(this._pureXbaseGrammarAccess.getSpecialBlockExpressionAccess().getSemicolonKeyword_1_1()).forEach(_function);
  EList<XExpression> _expressions = xBlockExpression.getExpressions();
  for (final XExpression xExpression : _expressions) {
    document.<XExpression>format(xExpression);
  }
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
@Check
public void checkDeadCode(XBlockExpression block) {
	List<XExpression> expressions = block.getExpressions();
	for(int i = 0, size = expressions.size(); i < size - 1; i++) {
		XExpression expression = expressions.get(i);
		if (earlyExitComputer.isEarlyExit(expression)) {
			if (!(expression instanceof XAbstractFeatureCall)) {
				// XAbstractFeatureCall does already a decent job for its argument lists
				// no additional error necessary
				markAsDeadCode(expressions.get(i + 1));
			}
			return;
		}
	}
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
protected void _toJavaStatement(XBlockExpression expr, ITreeAppendable b, boolean isReferenced) {
	b = b.trace(expr, false);
	if (expr.getExpressions().isEmpty())
		return;
	if (expr.getExpressions().size()==1) {
		internalToJavaStatement(expr.getExpressions().get(0), b, isReferenced);
		return;
	}
	if (isReferenced)
		declareSyntheticVariable(expr, b);
	boolean needsBraces = isReferenced || !bracesAreAddedByOuterStructure(expr);
	if (needsBraces) {
		b.newLine().append("{").increaseIndentation();
		b.openPseudoScope();
	}
	final EList<XExpression> expressions = expr.getExpressions();
	for (int i = 0; i < expressions.size(); i++) {
		XExpression ex = expressions.get(i);
		if (i < expressions.size() - 1) {
			internalToJavaStatement(ex, b, false);
		} else {
			internalToJavaStatement(ex, b, isReferenced);
			if (isReferenced) {
				b.newLine().append(getVarName(expr, b)).append(" = ");
				internalToConvertedExpression(ex, b, getLightweightType(expr));
				b.append(";");
			}
		}
	}
	if (needsBraces) {
		b.closeScope();
		b.decreaseIndentation().newLine().append("}");
	}
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
protected Object _doEvaluate(XBlockExpression literal, IEvaluationContext context, CancelIndicator indicator) {
	List<XExpression> expressions = literal.getExpressions();

	Object result = null;
	IEvaluationContext forkedContext = context.fork();
	for (int i = 0; i < expressions.size(); i++) {
		result = internalEvaluate(expressions.get(i), forkedContext, indicator);
	}
	return result;
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
protected Collection<IEarlyExitComputer.ExitPoint> _exitPoints(final XBlockExpression expression) {
  EList<XExpression> _expressions = expression.getExpressions();
  for (final XExpression child : _expressions) {
    {
      Collection<IEarlyExitComputer.ExitPoint> exitPoints = this.getExitPoints(child);
      boolean _isNotEmpty = this.isNotEmpty(exitPoints);
      if (_isNotEmpty) {
        return exitPoints;
      }
    }
  }
  return Collections.<IEarlyExitComputer.ExitPoint>emptyList();
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
protected boolean isValueExpectedRecursive(XExpression expr) {
	EStructuralFeature feature = expr.eContainingFeature();
	EObject container = expr.eContainer();
	
	// is part of block
	if (container instanceof XBlockExpression) {
		XBlockExpression blockExpression = (XBlockExpression) container;
		final List<XExpression> expressions = blockExpression.getExpressions();
		if (expressions.get(expressions.size()-1) != expr) {
			return false;
		}
	}
	// no expectation cases
	if (feature == XbasePackage.Literals.XTRY_CATCH_FINALLY_EXPRESSION__FINALLY_EXPRESSION
		|| feature == XbasePackage.Literals.XABSTRACT_WHILE_EXPRESSION__BODY
		|| feature == XbasePackage.Literals.XFOR_LOOP_EXPRESSION__EACH_EXPRESSION) {
		return false;
	}
	// is value expected
	if (container instanceof XAbstractFeatureCall 
		|| container instanceof XConstructorCall
		|| container instanceof XAssignment
		|| container instanceof XVariableDeclaration
		|| container instanceof XReturnExpression
		|| container instanceof XThrowExpression
		|| feature == XbasePackage.Literals.XFOR_LOOP_EXPRESSION__FOR_EXPRESSION
		|| feature == XbasePackage.Literals.XSWITCH_EXPRESSION__SWITCH
		|| feature == XbasePackage.Literals.XCASE_PART__CASE
		|| feature == XbasePackage.Literals.XIF_EXPRESSION__IF
		|| feature == XbasePackage.Literals.XABSTRACT_WHILE_EXPRESSION__PREDICATE
		|| feature == XbasePackage.Literals.XBASIC_FOR_LOOP_EXPRESSION__EXPRESSION
		|| feature == XbasePackage.Literals.XSYNCHRONIZED_EXPRESSION__PARAM) {
		return true;
	}
	if (isLocalClassSemantics(container) || logicalContainerProvider.getLogicalContainer(expr) != null) {
		LightweightTypeReference expectedReturnType = typeResolver.resolveTypes(expr).getExpectedReturnType(expr);
		return expectedReturnType == null || !expectedReturnType.isPrimitiveVoid();
	}
	if (container instanceof XCasePart || container instanceof XCatchClause) {
		container = container.eContainer();
	}
	if (container instanceof XExpression) {
		return isValueExpectedRecursive((XExpression) container);
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XBlockExpression; //导入方法依赖的package包/类
/**
 * Returns <code>true</code> for expressions that seem to be early exit expressions, e.g.
 * <pre>
 *   while(condition) {
 *     if (anotherCondition)
 *       return value
 *     changeResultOfFirstCondition
 *   }
 * </pre>
 */
public boolean isIntentionalEarlyExit(/* @Nullable */ XExpression expression) {
	if (expression == null) {
		return true;
	}
	if (expression instanceof XBlockExpression) {
		XBlockExpression block = (XBlockExpression) expression;
		List<XExpression> children = block.getExpressions();
		for(XExpression child: children) {
			if (isIntentionalEarlyExit(child)) {
				return true;
			}
		}
	} else if (expression instanceof XIfExpression) {
		return isIntentionalEarlyExit(((XIfExpression) expression).getThen()) 
				|| isIntentionalEarlyExit(((XIfExpression) expression).getElse());
	} else if (expression instanceof XSwitchExpression) {
		XSwitchExpression switchExpression = (XSwitchExpression) expression;
		for(XCasePart caseExpression: switchExpression.getCases()) {
			if (isIntentionalEarlyExit(caseExpression.getThen())) {
				return true;
			}
		}
		if (isIntentionalEarlyExit(switchExpression.getDefault())) {
			return true;
		}
	} else if (expression instanceof XTryCatchFinallyExpression) {
		XTryCatchFinallyExpression tryCatchFinally = (XTryCatchFinallyExpression) expression;
		if (isIntentionalEarlyExit(tryCatchFinally.getExpression())) {
			for(XCatchClause catchClause: tryCatchFinally.getCatchClauses()) {
				if (!isIntentionalEarlyExit(catchClause.getExpression()))
					return false;
			}
			return true;
		}
		return false;
	} else if (expression instanceof XAbstractWhileExpression) {
		return isIntentionalEarlyExit(((XAbstractWhileExpression) expression).getBody());
	} else if (expression instanceof XForLoopExpression) {
		return isIntentionalEarlyExit(((XForLoopExpression) expression).getEachExpression());
	} else if (expression instanceof XBasicForLoopExpression) {
		return isIntentionalEarlyExit(((XBasicForLoopExpression) expression).getEachExpression());
	} else if (expression instanceof XSynchronizedExpression) {
		return isIntentionalEarlyExit(((XSynchronizedExpression) expression).getExpression());
	}
	return expression instanceof XReturnExpression || expression instanceof XThrowExpression;
}