Java 类org.eclipse.xtext.xbase.XSetLiteral 实例源码

protected void _toJavaExpression(XSetLiteral literal, ITreeAppendable b) {
    LightweightTypeReference literalType = batchTypeResolver.resolveTypes(literal).getActualType(literal);
    if (literalType == null) {
        b.append("error - couldn't compute type for literal : "+literal);
        return;
    } 
    if (literalType.isType(Map.class)) {
        LightweightTypeReference keyType = literalType.getTypeArguments().get(0);
        LightweightTypeReference valueType = literalType.getTypeArguments().get(1);
        b.append(Collections.class)
            .append(".<").append(keyType).append(", ").append(valueType)
            .append(">unmodifiableMap(");
        b.append(CollectionLiterals.class).append(".<").append(keyType).append(", ").append(valueType).append(">newHashMap(");
        Iterator<XExpression> elements = literal.getElements().iterator();
        while(elements.hasNext())  {
            XExpression element = elements.next();
            internalToJavaExpression(element, b);
            if (elements.hasNext()) {
                b.append(", ");
            }
        }
        b.append("))");
    } else {
        appendImmutableCollectionExpression(literal, b, "unmodifiableSet", CollectionLiterals.class, "newHashSet");
    }
}

@Override
protected void appendImmutableCollectionExpression(final XCollectionLiteral literal, final ITreeAppendable b, final String collectionsMethod, final Class<?> guavaHelper, final String guavaHelperMethod) {
  // This is a work-around for a bug in the xbase compiler, which always constructs empty list literals #[] as List<Object>,
  // which then cannot be assigned (without cast) to any typed list. Note that this is not a problem in check; it also occurs
  // in plain xtend.
  if (literal.getElements().isEmpty()) {
    JvmType collectionsClass = findKnownTopLevelType(Collections.class, literal);
    if (collectionsClass != null) {
      if (literal instanceof XListLiteral) {
        b.append(collectionsClass).append(".emptyList()");
        return;
      } else if (literal instanceof XSetLiteral) {
        b.append(collectionsClass).append(".emptySet()");
        return;
      }
    }
  }
  super.appendImmutableCollectionExpression(literal, b, collectionsMethod, guavaHelper, guavaHelperMethod);
}

/**
 * Entry point from the {@link XbaseTypeComputer}.
 */
public void computeType(XSetLiteral literal, ITypeComputationState state) {
    JvmGenericType setType = findDeclaredType(Set.class, state);
    if (setType == null) {
        handleCollectionTypeNotAvailable(literal, state, Set.class);
        return;
    }
    JvmGenericType mapType = findDeclaredType(Map.class, state);
    for(ITypeExpectation expectation: state.getExpectations()) {
        computeType(literal, setType, mapType, expectation, state);
    }
}

protected void computeType(XSetLiteral literal, JvmGenericType setType, JvmGenericType mapType, ITypeExpectation expectation, ITypeComputationState state) {
    LightweightTypeReference elementTypeExpectation = null;
    LightweightTypeReference expectedType = expectation.getExpectedType();
    if(expectedType != null) {
        elementTypeExpectation = getElementOrComponentType(expectedType, state);
    }
    List<LightweightTypeReference> setTypeCandidates = computeCollectionTypeCandidates(literal, setType, elementTypeExpectation, state);
    LightweightTypeReference commonSetType = getCommonSuperType(setTypeCandidates, state);
    ITypeReferenceOwner owner = state.getReferenceOwner();
    if(commonSetType != null) {
        LightweightTypeReference commonElementType = commonSetType.getTypeArguments().get(0).getInvariantBoundSubstitute();
        if(isMapLiteral(expectedType, commonElementType)) {
            LightweightTypeReference mapTypeReference = createMapTypeReference(mapType, commonElementType, expectedType, owner);
            expectation.acceptActualType(mapTypeReference, ConformanceFlags.UNCHECKED);
            commonElementType = createNormalizedPairType(commonElementType, mapTypeReference, owner);
            refineElementTypeExpectation(literal, commonElementType, state);
        } else {
            commonElementType = normalizeElementType(commonElementType, expectedType, owner);
            if (expectedType != null) {
                commonSetType = createCollectionTypeReference(setType, commonElementType, expectedType, owner);
            }
            expectation.acceptActualType(commonSetType, ConformanceFlags.UNCHECKED);
            refineElementTypeExpectation(literal, commonElementType, state);
        }
    } else {
        if(isMapExpectation(expectedType)) {
            ParameterizedTypeReference unboundCollectionType = owner.newParameterizedTypeReference(mapType);
            unboundCollectionType.addTypeArgument(expectation.createUnboundTypeReference(literal, mapType.getTypeParameters().get(0)));
            unboundCollectionType.addTypeArgument(expectation.createUnboundTypeReference(literal, mapType.getTypeParameters().get(1)));
            expectation.acceptActualType(unboundCollectionType, ConformanceFlags.UNCHECKED);
        } else {
            setUnboundCollectionType(literal, setType, expectation, elementTypeExpectation, state);
        }
    }
}

@Override
protected void internalToConvertedExpression(XExpression obj, ITreeAppendable appendable) {
    if (obj instanceof XBlockExpression) {
        _toJavaExpression((XBlockExpression) obj, appendable);
    } else if (obj instanceof XCastedExpression) {
        _toJavaExpression((XCastedExpression) obj, appendable);
    } else if (obj instanceof XClosure) {
        _toJavaExpression((XClosure) obj, appendable);
    } else if (obj instanceof XAnnotation) {
        _toJavaExpression((XAnnotation) obj, appendable);
    } else if (obj instanceof XConstructorCall) {
        _toJavaExpression((XConstructorCall) obj, appendable);
    } else if (obj instanceof XIfExpression) {
        _toJavaExpression((XIfExpression) obj, appendable);
    } else if (obj instanceof XInstanceOfExpression) {
        _toJavaExpression((XInstanceOfExpression) obj, appendable);
    } else if (obj instanceof XSwitchExpression) {
        _toJavaExpression((XSwitchExpression) obj, appendable);
    } else if (obj instanceof XTryCatchFinallyExpression) {
        _toJavaExpression((XTryCatchFinallyExpression) obj, appendable);
    } else if (obj instanceof XListLiteral) {
        _toJavaExpression((XListLiteral) obj, appendable);
    } else if (obj instanceof XSetLiteral) {
        _toJavaExpression((XSetLiteral) obj, appendable);
    } else if (obj instanceof XSynchronizedExpression) {
        _toJavaExpression((XSynchronizedExpression) obj, appendable);
    } else if (obj instanceof XReturnExpression) {
        _toJavaExpression((XReturnExpression) obj, appendable);
    } else if (obj instanceof XThrowExpression) {
        _toJavaExpression((XThrowExpression) obj, appendable);
    } else {
        super.internalToConvertedExpression(obj, appendable);
    }
}

@Deprecated
protected void sequence_XSetLiteral(EObject context, XSetLiteral semanticObject) {
    sequence_XSetLiteral(createContext(context, semanticObject), semanticObject);
}

@Override
public void computeTypes(XExpression expression, ITypeComputationState state) {
    if (expression instanceof XAssignment) {
        _computeTypes((XAssignment)expression, state);
    } else if (expression instanceof XAbstractFeatureCall) {
        _computeTypes((XAbstractFeatureCall)expression, state);
    } else if (expression instanceof XDoWhileExpression) {
        _computeTypes((XDoWhileExpression)expression, state);
    } else if (expression instanceof XWhileExpression) {
        _computeTypes((XWhileExpression)expression, state);
    } else if (expression instanceof XBlockExpression) {
        _computeTypes((XBlockExpression)expression, state);
    } else if (expression instanceof XBooleanLiteral) {
        _computeTypes((XBooleanLiteral)expression, state);
    } else if (expression instanceof XCastedExpression) {
        _computeTypes((XCastedExpression)expression, state);
    } else if (expression instanceof XClosure) {
        _computeTypes((XClosure)expression, state);
    } else if (expression instanceof XConstructorCall) {
        _computeTypes((XConstructorCall)expression, state);
    } else if (expression instanceof XForLoopExpression) {
        _computeTypes((XForLoopExpression)expression, state);
    } else if (expression instanceof XBasicForLoopExpression) {
        _computeTypes((XBasicForLoopExpression)expression, state);
    } else if (expression instanceof XIfExpression) {
        _computeTypes((XIfExpression)expression, state);
    } else if (expression instanceof XInstanceOfExpression) {
        _computeTypes((XInstanceOfExpression)expression, state);
    } else if (expression instanceof XNumberLiteral) {
        _computeTypes((XNumberLiteral)expression, state);
    } else if (expression instanceof XNullLiteral) {
        _computeTypes((XNullLiteral)expression, state);
    } else if (expression instanceof XReturnExpression) {
        _computeTypes((XReturnExpression)expression, state);
    } else if (expression instanceof XStringLiteral) {
        _computeTypes((XStringLiteral)expression, state);
    } else if (expression instanceof XSwitchExpression) {
        _computeTypes((XSwitchExpression)expression, state);
    } else if (expression instanceof XThrowExpression) {
        _computeTypes((XThrowExpression)expression, state);
    } else if (expression instanceof XTryCatchFinallyExpression) {
        _computeTypes((XTryCatchFinallyExpression)expression, state);
    } else if (expression instanceof XTypeLiteral) {
        _computeTypes((XTypeLiteral)expression, state);
    } else if (expression instanceof XVariableDeclaration) {
        _computeTypes((XVariableDeclaration)expression, state);
    } else if (expression instanceof XListLiteral) {
        _computeTypes((XListLiteral)expression, state);
    } else if (expression instanceof XSetLiteral) {
        _computeTypes((XSetLiteral)expression, state);
    } else if (expression instanceof XSynchronizedExpression) {
        _computeTypes((XSynchronizedExpression)expression, state);
    } else {
        throw new UnsupportedOperationException("Missing type computation for expression type: " + expression.eClass().getName() + " / " + state);
    }
}

protected void _computeTypes(XSetLiteral literal, ITypeComputationState state) {
    collectionLiterals.computeType(literal, state);
}

/**
 * @param isReferenced unused in this context but necessary for dispatch signature 
 */
protected void _toJavaStatement(final XSetLiteral literal, ITreeAppendable b, boolean isReferenced) {
    for(XExpression element: literal.getElements()) 
        internalToJavaStatement(element, b, true);
}

@Override
protected void doInternalToJavaStatement(XExpression obj, ITreeAppendable appendable, boolean isReferenced) {
    if (obj instanceof XBlockExpression) {
        _toJavaStatement((XBlockExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XCastedExpression) {
        _toJavaStatement((XCastedExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XClosure) {
        _toJavaStatement((XClosure) obj, appendable, isReferenced);
    } else if (obj instanceof XConstructorCall) {
        _toJavaStatement((XConstructorCall) obj, appendable, isReferenced);
    } else if (obj instanceof XDoWhileExpression) {
        _toJavaStatement((XDoWhileExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XForLoopExpression) {
        _toJavaStatement((XForLoopExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XBasicForLoopExpression) {
        _toJavaStatement((XBasicForLoopExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XIfExpression) {
        _toJavaStatement((XIfExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XInstanceOfExpression) {
        _toJavaStatement((XInstanceOfExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XReturnExpression) {
        _toJavaStatement((XReturnExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XSwitchExpression) {
        _toJavaStatement((XSwitchExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XThrowExpression) {
        _toJavaStatement((XThrowExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XTryCatchFinallyExpression) {
        _toJavaStatement((XTryCatchFinallyExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XVariableDeclaration) {
        _toJavaStatement((XVariableDeclaration) obj, appendable, isReferenced);
    } else if (obj instanceof XWhileExpression) {
        _toJavaStatement((XWhileExpression) obj, appendable, isReferenced);
    } else if (obj instanceof XListLiteral) {
        _toJavaStatement((XListLiteral) obj, appendable, isReferenced);
    } else if (obj instanceof XSetLiteral) {
        _toJavaStatement((XSetLiteral) obj, appendable, isReferenced);
    } else if (obj instanceof XSynchronizedExpression) {
        _toJavaStatement((XSynchronizedExpression) obj, appendable, isReferenced);
    } else {
        super.doInternalToJavaStatement(obj, appendable, isReferenced);
    }
}

@Override
protected boolean isVariableDeclarationRequired(XExpression expr, ITreeAppendable b, boolean recursive) {
    if (expr instanceof XAnnotation) {
        return false;
    }
    if (expr instanceof XListLiteral) {
        return false;
    }
    if (expr instanceof XSetLiteral) {
        return false;
    }
    if (expr instanceof XCastedExpression) {
        return false;
    }
    if (expr instanceof XInstanceOfExpression) {
        return false;
    }
    if (expr instanceof XMemberFeatureCall && isVariableDeclarationRequired((XMemberFeatureCall) expr, b))
        return true;
    EObject container = expr.eContainer();
    if ((container instanceof XVariableDeclaration)
        || (container instanceof XReturnExpression) 
        || (container instanceof XThrowExpression)) {
        return false;
    }
    if (container instanceof XIfExpression) {
        XIfExpression ifExpression = (XIfExpression) container;
        if (ifExpression.getThen() == expr || ifExpression.getElse() == expr) {
            return false;
        }
    }
    if (container instanceof XCasePart) {
        XCasePart casePart = (XCasePart) container;
        if (casePart.getThen() == expr) {
            return false;
        }
    }
    if (container instanceof XSwitchExpression) {
        XSwitchExpression switchExpression = (XSwitchExpression) container;
        if (switchExpression.getDefault() == expr) {
            return false;
        }
    }
    if (container instanceof XBlockExpression) {
        List<XExpression> siblings = ((XBlockExpression) container).getExpressions();
        if (siblings.get(siblings.size() - 1) == expr) {
            return isVariableDeclarationRequired(getFeatureCall(expr), expr, b);
        }
    }
    if (container instanceof XClosure) {
        if (((XClosure) container).getExpression() == expr) {
            return false;
        }
    }
    if (expr instanceof XAssignment) {
        XAssignment a = (XAssignment) expr;
        for (XExpression arg : getActualArguments(a)) {
            if (isVariableDeclarationRequired(arg, b, recursive)) {
                return true;
            }
        }
    }
    return super.isVariableDeclarationRequired(expr, b, recursive);
}

/**
 * don't call this directly. Always call evaluate() internalEvaluate()
 */
protected Object doEvaluate(XExpression expression, IEvaluationContext context, CancelIndicator indicator) {
    if (expression instanceof XAssignment) {
      return _doEvaluate((XAssignment)expression, context, indicator);
    } else if (expression instanceof XDoWhileExpression) {
      return _doEvaluate((XDoWhileExpression)expression, context, indicator);
    } else if (expression instanceof XMemberFeatureCall) {
      return _doEvaluate((XMemberFeatureCall)expression, context, indicator);
    } else if (expression instanceof XWhileExpression) {
      return _doEvaluate((XWhileExpression)expression, context, indicator);
    } else if (expression instanceof XFeatureCall) {
        return _doEvaluate((XFeatureCall)expression, context, indicator);
    } else if (expression instanceof XAbstractFeatureCall) {
        return _doEvaluate((XAbstractFeatureCall)expression, context, indicator);
    } else if (expression instanceof XBlockExpression) {
      return _doEvaluate((XBlockExpression)expression, context, indicator);
    } else if (expression instanceof XSynchronizedExpression) {
      return _doEvaluate((XSynchronizedExpression)expression, context, indicator);
    } else if (expression instanceof XBooleanLiteral) {
      return _doEvaluate((XBooleanLiteral)expression, context, indicator);
    } else if (expression instanceof XCastedExpression) {
      return _doEvaluate((XCastedExpression)expression, context, indicator);
    } else if (expression instanceof XClosure) {
      return _doEvaluate((XClosure)expression, context, indicator);
    } else if (expression instanceof XConstructorCall) {
      return _doEvaluate((XConstructorCall)expression, context, indicator);
    } else if (expression instanceof XForLoopExpression) {
      return _doEvaluate((XForLoopExpression)expression, context, indicator);
    } else if (expression instanceof XBasicForLoopExpression) {
      return _doEvaluate((XBasicForLoopExpression)expression, context, indicator);
    } else if (expression instanceof XIfExpression) {
      return _doEvaluate((XIfExpression)expression, context, indicator);
    } else if (expression instanceof XInstanceOfExpression) {
      return _doEvaluate((XInstanceOfExpression)expression, context, indicator);
    } else if (expression instanceof XNullLiteral) {
      return _doEvaluate((XNullLiteral)expression, context, indicator);
    } else if (expression instanceof XNumberLiteral) {
      return _doEvaluate((XNumberLiteral)expression, context, indicator);
    } else if (expression instanceof XReturnExpression) {
      return _doEvaluate((XReturnExpression)expression, context, indicator);
    } else if (expression instanceof XStringLiteral) {
      return _doEvaluate((XStringLiteral)expression, context, indicator);
    } else if (expression instanceof XSwitchExpression) {
      return _doEvaluate((XSwitchExpression)expression, context, indicator);
    } else if (expression instanceof XThrowExpression) {
      return _doEvaluate((XThrowExpression)expression, context, indicator);
    } else if (expression instanceof XTryCatchFinallyExpression) {
      return _doEvaluate((XTryCatchFinallyExpression)expression, context, indicator);
    } else if (expression instanceof XTypeLiteral) {
      return _doEvaluate((XTypeLiteral)expression, context, indicator);
    } else if (expression instanceof XVariableDeclaration) {
          return _doEvaluate((XVariableDeclaration)expression, context, indicator);
    } else if (expression instanceof XListLiteral) {
          return _doEvaluate((XListLiteral)expression, context, indicator);
    } else if (expression instanceof XSetLiteral) {
          return _doEvaluate((XSetLiteral)expression, context, indicator);
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(expression, context, indicator).toString());
    }
}

/**
 * Contexts:
 *     XExpression returns XSetLiteral
 *     XAssignment returns XSetLiteral
 *     XAssignment.XBinaryOperation_1_1_0_0_0 returns XSetLiteral
 *     XOrExpression returns XSetLiteral
 *     XOrExpression.XBinaryOperation_1_0_0_0 returns XSetLiteral
 *     XAndExpression returns XSetLiteral
 *     XAndExpression.XBinaryOperation_1_0_0_0 returns XSetLiteral
 *     XEqualityExpression returns XSetLiteral
 *     XEqualityExpression.XBinaryOperation_1_0_0_0 returns XSetLiteral
 *     XRelationalExpression returns XSetLiteral
 *     XRelationalExpression.XInstanceOfExpression_1_0_0_0_0 returns XSetLiteral
 *     XRelationalExpression.XBinaryOperation_1_1_0_0_0 returns XSetLiteral
 *     XOtherOperatorExpression returns XSetLiteral
 *     XOtherOperatorExpression.XBinaryOperation_1_0_0_0 returns XSetLiteral
 *     XAdditiveExpression returns XSetLiteral
 *     XAdditiveExpression.XBinaryOperation_1_0_0_0 returns XSetLiteral
 *     XMultiplicativeExpression returns XSetLiteral
 *     XMultiplicativeExpression.XBinaryOperation_1_0_0_0 returns XSetLiteral
 *     XUnaryOperation returns XSetLiteral
 *     XCastedExpression returns XSetLiteral
 *     XCastedExpression.XCastedExpression_1_0_0_0 returns XSetLiteral
 *     XPostfixOperation returns XSetLiteral
 *     XPostfixOperation.XPostfixOperation_1_0_0 returns XSetLiteral
 *     XMemberFeatureCall returns XSetLiteral
 *     XMemberFeatureCall.XAssignment_1_0_0_0_0 returns XSetLiteral
 *     XMemberFeatureCall.XMemberFeatureCall_1_1_0_0_0 returns XSetLiteral
 *     XPrimaryExpression returns XSetLiteral
 *     XLiteral returns XSetLiteral
 *     XCollectionLiteral returns XSetLiteral
 *     XSetLiteral returns XSetLiteral
 *     XParenthesizedExpression returns XSetLiteral
 *     XExpressionOrVarDeclaration returns XSetLiteral
 *
 * Constraint:
 *     (elements+=XExpression elements+=XExpression*)?
 */
protected void sequence_XSetLiteral(ISerializationContext context, XSetLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     ((elements+=XExpression elements+=XExpression*)?)
 */
protected void sequence_XSetLiteral(EObject context, XSetLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}

/**
 * Constraint:
 *     ((elements+=XExpression elements+=XExpression*)?)
 */
protected void sequence_XSetLiteral(EObject context, XSetLiteral semanticObject) {
    genericSequencer.createSequence(context, semanticObject);
}