Java XSwitchExpression类代码示例

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
@Check
public void checkTypeGuardsOrder(XSwitchExpression expression) {
	if (isIgnored(IssueCodes.UNREACHABLE_CASE)) {
		return;
	}
	ITypeReferenceOwner owner = new StandardTypeReferenceOwner(getServices(), expression);
	List<LightweightTypeReference> previousTypeReferences = new ArrayList<LightweightTypeReference>();
	for (XCasePart casePart : expression.getCases()) {
		JvmTypeReference typeGuard = casePart.getTypeGuard();
		if (typeGuard == null) {
			continue;
		}
		LightweightTypeReference actualType = owner.toLightweightTypeReference(typeGuard);
		if (actualType == null) {
			continue;
		}
		if (isHandled(actualType, previousTypeReferences)) {
			addIssue("Unreachable code: The case can never match. It is already handled by a previous condition.", typeGuard, IssueCodes.UNREACHABLE_CASE);
			continue;
		}
		if (casePart.getCase() == null) {
			previousTypeReferences.add(actualType);
		}
	}
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
@Check
public void checkTypeGuardsOrderWithGenerics(XSwitchExpression expression) {
	if (isIgnored(IssueCodes.UNREACHABLE_CASE)) {
		return;
	}
	ITypeReferenceOwner owner = new StandardTypeReferenceOwner(getServices(), expression);
	List<LightweightTypeReference> previousTypeReferences = new ArrayList<LightweightTypeReference>();
	for (XCasePart casePart : expression.getCases()) {
		JvmTypeReference typeGuard = casePart.getTypeGuard();
		if (typeGuard == null) {
			continue;
		}
		LightweightTypeReference typeReference = owner.toLightweightTypeReference(typeGuard);
		LightweightTypeReference actualType = typeReference.getRawTypeReference();
		if (actualType == null || typeReference == actualType) {
			continue;
		}
		if (isHandled(actualType, previousTypeReferences)) {
			addIssue("Unreachable code: The case can never match. It is already handled by a previous condition (with the same type erasure).", typeGuard, IssueCodes.UNREACHABLE_CASE);
			continue;
		}
		if (casePart.getCase() == null) {
			previousTypeReferences.add(actualType);
		}
	}
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
public IScope createFeatureCallSerializationScope(EObject context) {
	if (!(context instanceof XAbstractFeatureCall)) {
		return IScope.NULLSCOPE;
	}
	XAbstractFeatureCall call = (XAbstractFeatureCall) context;
	JvmIdentifiableElement feature = call.getFeature();
	// this and super - logical container aware FeatureScopes
	if (feature instanceof JvmType) {
		return getTypeScope(call, (JvmType) feature);
	}
	if (feature instanceof JvmConstructor) {
		return getThisOrSuperScope(call, (JvmConstructor) feature);
	}
	if (feature instanceof JvmExecutable) {
		return getExecutableScope(call, feature);
	}
	if (feature instanceof JvmFormalParameter || feature instanceof JvmField || feature instanceof XVariableDeclaration || feature instanceof XSwitchExpression) {
		return new SingletonScope(EObjectDescription.create(feature.getSimpleName(), feature), IScope.NULLSCOPE);
	}
	return IScope.NULLSCOPE;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
protected String declareLocalVariable(XSwitchExpression expr, ITreeAppendable b) {
	// declare local var for the switch expression
	String variableName = getSwitchLocalVariableName(expr, b); 
	if (variableName != null) {
		return variableName;
	}
	String name = createSwitchLocalVariableName(expr);
	JvmTypeReference variableType = getSwitchLocalVariableType(expr);
	b.newLine().append("final ");
	serialize(variableType, expr, b);
	b.append(" ");
	variableName = declareAndAppendSwitchSyntheticLocalVariable(expr, name, b);
	b.append(" = ");
	internalToJavaExpression(expr.getSwitch(), b);
	b.append(";");
	return variableName;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
protected String getSwitchLocalVariableName(XSwitchExpression expr, ITreeAppendable b) {
	JvmFormalParameter declaredParam = expr.getDeclaredParam();
	if (declaredParam != null) {
		if (b.hasName(declaredParam)) {
			return b.getName(declaredParam);
		}
		return null;
	}
	XExpression switchExpression = expr.getSwitch();
	if (b.hasName(switchExpression)) {
		return b.getName(switchExpression);
	} 
	if (switchExpression instanceof XFeatureCall) {
		XFeatureCall featureCall = (XFeatureCall) switchExpression;
		JvmIdentifiableElement feature = featureCall.getFeature();
		if (b.hasName(feature)) {
			return b.getName(feature);
		}
	}
	return null;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
/**
 * Determine whether the given switch expression should be compiled to a Java switch for Java version 7 or higher.
 */
protected boolean isCompiledToJava7Switch(XSwitchExpression expr) {
	// NOTE: This method could be merged with #isCompiledToJavaSwitch(XSwitchExpression)
	if (!switchExpressions.isJava7SwitchExpression(expr)) {
		return false;
	}
	for (XCasePart casePart : expr.getCases()) {
		if (!switchExpressions.isJavaCaseExpression(expr, casePart)) {
			return false;
		}
		if (!switchExpressions.isConstant(casePart)) {
			return false;
		}
	}
	return true;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
protected ILocationData getLocationOfDefault(XSwitchExpression expression) {
	final ICompositeNode startNode = NodeModelUtils.getNode(expression);
	if (startNode != null) {
		List<INode> resultNodes = Lists.newArrayList();
		boolean defaultSeen = false;
		for (INode child : startNode.getChildren()) {
			if (defaultSeen) {
				resultNodes.add(child);
				if (GrammarUtil.containingAssignment(child.getGrammarElement()) != null) {
					break;
				}
			} else if (child.getGrammarElement() instanceof Keyword && "default".equals(child.getText())) {
				defaultSeen = true;
				resultNodes.add(child);
			}
		}
		return toLocationData(resultNodes);
	}
	return null;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
/**
 * Determine whether the given switch expression is valid for Java version 6 or lower.
 */
public boolean isJavaSwitchExpression(final XSwitchExpression it) {
  boolean _xblockexpression = false;
  {
    final LightweightTypeReference switchType = this.getSwitchVariableType(it);
    if ((switchType == null)) {
      return false;
    }
    boolean _isSubtypeOf = switchType.isSubtypeOf(Integer.TYPE);
    if (_isSubtypeOf) {
      return true;
    }
    boolean _isSubtypeOf_1 = switchType.isSubtypeOf(Enum.class);
    if (_isSubtypeOf_1) {
      return true;
    }
    _xblockexpression = false;
  }
  return _xblockexpression;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
/**
 * Determine whether the given switch expression is valid for Java version 7 or higher.
 */
public boolean isJava7SwitchExpression(final XSwitchExpression it) {
  boolean _xblockexpression = false;
  {
    final LightweightTypeReference switchType = this.getSwitchVariableType(it);
    if ((switchType == null)) {
      return false;
    }
    boolean _isSubtypeOf = switchType.isSubtypeOf(Integer.TYPE);
    if (_isSubtypeOf) {
      return true;
    }
    boolean _isSubtypeOf_1 = switchType.isSubtypeOf(Enum.class);
    if (_isSubtypeOf_1) {
      return true;
    }
    boolean _isSubtypeOf_2 = switchType.isSubtypeOf(String.class);
    if (_isSubtypeOf_2) {
      return true;
    }
    _xblockexpression = false;
  }
  return _xblockexpression;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
public LightweightTypeReference getSwitchVariableType(final XSwitchExpression it) {
  @Extension
  final IResolvedTypes resolvedTypes = this._iBatchTypeResolver.resolveTypes(it);
  final JvmFormalParameter declaredParam = it.getDeclaredParam();
  if ((declaredParam == null)) {
    return resolvedTypes.getActualType(it.getSwitch());
  }
  final LightweightTypeReference paramType = resolvedTypes.getActualType(declaredParam);
  LightweightTypeReference _elvis = null;
  if (paramType != null) {
    _elvis = paramType;
  } else {
    LightweightTypeReference _actualType = resolvedTypes.getActualType(it.getSwitch());
    _elvis = _actualType;
  }
  return _elvis;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
public XExpression getThen(final XCasePart casePart, final XSwitchExpression switchExpression) {
  final XExpression then = casePart.getThen();
  if ((then != null)) {
    return then;
  }
  final int casePartIndex = switchExpression.getCases().indexOf(casePart);
  if ((casePartIndex == (-1))) {
    return null;
  }
  final int count = switchExpression.getCases().size();
  if ((casePartIndex == (count - 1))) {
    return switchExpression.getDefault();
  }
  if (((casePartIndex + 1) < count)) {
    return this.getThen(switchExpression.getCases().get((casePartIndex + 1)), switchExpression);
  }
  return null;
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
@Check
public void checkTypeGuards(XCasePart casePart) {
	if (casePart.getTypeGuard() == null)
		return;
	LightweightTypeReference typeGuard = toLightweightTypeReference(casePart.getTypeGuard());
	if (typeGuard.isPrimitive()) {
		error("Primitives are not allowed as type guards", Literals.XCASE_PART__TYPE_GUARD, INVALID_USE_OF_TYPE);
		return;
	}
	LightweightTypeReference targetTypeRef = getActualType(((XSwitchExpression) casePart.eContainer()).getSwitch());
	checkCast(casePart.getTypeGuard(), typeGuard, targetTypeRef);
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
@Check
public void checkLocalUsageOfSwitchParameter(XSwitchExpression switchExpression) {
	JvmFormalParameter switchParam = switchExpression.getDeclaredParam();
	if(!isIgnored(UNUSED_LOCAL_VARIABLE) && switchParam != null && !isLocallyUsed(switchParam, switchExpression)){
		String message = "The value of the local variable " + switchParam.getName() + " is not used";
		addIssue(message, switchParam, TypesPackage.Literals.JVM_FORMAL_PARAMETER__NAME, UNUSED_LOCAL_VARIABLE);
	}
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
@Check
public void checkRedundantCase(XSwitchExpression switchExpression) {
	XCasePart casePart = IterableExtensions.last(switchExpression.getCases());
	if (casePart == null || !(casePart.isFallThrough() && casePart.getThen() == null)) {
		return;
	}
	if (switchExpression.getDefault() == null) {
		error("Redundant case.", casePart, null, IssueCodes.REDUNDANT_CASE);
	} else {
		warning("Redundant case.", casePart, null, IssueCodes.REDUNDANT_CASE);
	}
}
 

import org.eclipse.xtext.xbase.XSwitchExpression; //导入依赖的package包/类
@Check
public void checkDeadCode(XSwitchExpression switchExpression) {
	List<XCasePart> cases = switchExpression.getCases();
	for(int i = 0, size = cases.size(); i < size; i++) {
		XCasePart casePart = cases.get(i);
		XExpression caseExpression = casePart.getCase();
		if (!earlyExitComputer.isEarlyExit(caseExpression)) {
			validateCondition(caseExpression, false);
		} else if (!markAsDeadCode(casePart.getThen())) {
			if (casePart.getTypeGuard() == null) { 
				i = markAsDeadCode(cases, casePart, i, size);
			}
		}
	}
}