Example usage for org.eclipse.jdt.internal.compiler.ast OperatorIds EQUAL_EQUAL

List of usage examples for org.eclipse.jdt.internal.compiler.ast OperatorIds EQUAL_EQUAL

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.internal.compiler.ast.*
  5. OperatorIds
  6. EQUAL_EQUAL

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.ast OperatorIds EQUAL_EQUAL.

Prototype

int EQUAL_EQUAL

To view the source code for org.eclipse.jdt.internal.compiler.ast OperatorIds EQUAL_EQUAL.

Click Source Link

Usage

From source file:com.android.tools.lint.psi.EcjPsiBuilder.java

License:Apache License

/** Look up the PSI element type for the given ECJ operator */
@NonNull/*from   w  w w .j av a2 s. c  om*/
private IElementType ecjToPsiToken(int operator) {
    switch (operator) {
    case OperatorIds.PLUS_PLUS:
        return JavaTokenType.PLUSPLUS;
    case OperatorIds.MINUS_MINUS:
        return JavaTokenType.MINUSMINUS;
    case OperatorIds.TWIDDLE:
        return JavaTokenType.TILDE;
    case OperatorIds.NOT:
        return JavaTokenType.EXCL;
    case OperatorIds.PLUS:
        return JavaTokenType.PLUS;
    case OperatorIds.MINUS:
        return JavaTokenType.MINUS;
    case OperatorIds.OR_OR:
        return JavaTokenType.OROR;
    case OperatorIds.AND_AND:
        return JavaTokenType.ANDAND;
    case OperatorIds.OR:
        return JavaTokenType.OR;
    case OperatorIds.XOR:
        return JavaTokenType.XOR;
    case OperatorIds.AND:
        return JavaTokenType.AND;
    case OperatorIds.EQUAL_EQUAL:
        return JavaTokenType.EQEQ;
    case OperatorIds.NOT_EQUAL:
        return JavaTokenType.NE;
    case OperatorIds.GREATER:
        return JavaTokenType.GT;
    case OperatorIds.GREATER_EQUAL:
        return JavaTokenType.GE;
    case OperatorIds.LESS:
        return JavaTokenType.LT;
    case OperatorIds.LESS_EQUAL:
        return JavaTokenType.LE;
    case OperatorIds.LEFT_SHIFT:
        return JavaTokenType.LTLT;
    case OperatorIds.RIGHT_SHIFT:
        return JavaTokenType.GTGT;
    case OperatorIds.UNSIGNED_RIGHT_SHIFT:
        return JavaTokenType.GTGTGT;
    case OperatorIds.MULTIPLY:
        return JavaTokenType.ASTERISK;
    case OperatorIds.DIVIDE:
        return JavaTokenType.DIV;
    case OperatorIds.REMAINDER:
        return JavaTokenType.PERC;
    case OperatorIds.EQUAL:
        return JavaTokenType.EQ;
    default:
        return JavaTokenType.IDENTIFIER;
    }
}

From source file:lombok.eclipse.handlers.EclipseHandlerUtil.java

License:Open Source License

/**
 * Generates a new statement that checks if the given variable is null, and if so, throws a specified exception with the
 * variable name as message./*from   ww  w  .  ja v  a2s  . co  m*/
 * 
 * @param exName The name of the exception to throw; normally {@code java.lang.NullPointerException}.
 */
public static Statement generateNullCheck(AbstractVariableDeclaration variable, EclipseNode sourceNode) {
    NullCheckExceptionType exceptionType = sourceNode.getAst()
            .readConfiguration(ConfigurationKeys.NON_NULL_EXCEPTION_TYPE);
    if (exceptionType == null)
        exceptionType = NullCheckExceptionType.NULL_POINTER_EXCEPTION;

    ASTNode source = sourceNode.get();

    int pS = source.sourceStart, pE = source.sourceEnd;
    long p = (long) pS << 32 | pE;

    if (isPrimitive(variable.type))
        return null;
    AllocationExpression exception = new AllocationExpression();
    setGeneratedBy(exception, source);
    int partCount = 1;
    String exceptionTypeStr = exceptionType.getExceptionType();
    for (int i = 0; i < exceptionTypeStr.length(); i++)
        if (exceptionTypeStr.charAt(i) == '.')
            partCount++;
    long[] ps = new long[partCount];
    Arrays.fill(ps, 0L);
    exception.type = new QualifiedTypeReference(fromQualifiedName(exceptionTypeStr), ps);
    setGeneratedBy(exception.type, source);
    exception.arguments = new Expression[] { new StringLiteral(
            exceptionType.toExceptionMessage(new String(variable.name)).toCharArray(), pS, pE, 0) };
    setGeneratedBy(exception.arguments[0], source);
    ThrowStatement throwStatement = new ThrowStatement(exception, pS, pE);
    setGeneratedBy(throwStatement, source);

    SingleNameReference varName = new SingleNameReference(variable.name, p);
    setGeneratedBy(varName, source);
    NullLiteral nullLiteral = new NullLiteral(pS, pE);
    setGeneratedBy(nullLiteral, source);
    EqualExpression equalExpression = new EqualExpression(varName, nullLiteral, OperatorIds.EQUAL_EQUAL);
    equalExpression.sourceStart = pS;
    equalExpression.statementEnd = equalExpression.sourceEnd = pE;
    setGeneratedBy(equalExpression, source);
    Block throwBlock = new Block(0);
    throwBlock.statements = new Statement[] { throwStatement };
    throwBlock.sourceStart = pS;
    throwBlock.sourceEnd = pE;
    setGeneratedBy(throwBlock, source);
    IfStatement ifStatement = new IfStatement(equalExpression, throwBlock, 0, 0);
    setGeneratedBy(ifStatement, source);
    return ifStatement;
}

From source file:lombok.eclipse.handlers.HandleEqualsAndHashCode.java

License:Open Source License

public MethodDeclaration createHashCode(EclipseNode type, Collection<EclipseNode> fields, boolean callSuper,
        ASTNode source, FieldAccess fieldAccess) {
    int pS = source.sourceStart, pE = source.sourceEnd;
    long p = (long) pS << 32 | pE;

    MethodDeclaration method = new MethodDeclaration(
            ((CompilationUnitDeclaration) type.top().get()).compilationResult);
    setGeneratedBy(method, source);//from  w  w  w  .  ja  v  a 2  s  .  c o m

    method.modifiers = toEclipseModifier(AccessLevel.PUBLIC);
    method.returnType = TypeReference.baseTypeReference(TypeIds.T_int, 0);
    setGeneratedBy(method.returnType, source);
    method.annotations = new Annotation[] { makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source) };
    method.selector = "hashCode".toCharArray();
    method.thrownExceptions = null;
    method.typeParameters = null;
    method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
    method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
    method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;
    method.arguments = null;

    List<Statement> statements = new ArrayList<Statement>();

    final boolean isEmpty = fields.isEmpty();

    /* final int PRIME = X; */ {
        /* Without fields, PRIME isn't used, and that would trigger a 'local variable not used' warning. */
        if (!isEmpty || callSuper) {
            LocalDeclaration primeDecl = new LocalDeclaration(PRIME, pS, pE);
            setGeneratedBy(primeDecl, source);
            primeDecl.modifiers |= Modifier.FINAL;
            primeDecl.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
            primeDecl.type.sourceStart = pS;
            primeDecl.type.sourceEnd = pE;
            setGeneratedBy(primeDecl.type, source);
            primeDecl.initialization = makeIntLiteral(
                    String.valueOf(HandlerUtil.primeForHashcode()).toCharArray(), source);
            statements.add(primeDecl);
        }
    }

    /* int result = 1; */ {
        LocalDeclaration resultDecl = new LocalDeclaration(RESULT, pS, pE);
        setGeneratedBy(resultDecl, source);
        resultDecl.initialization = makeIntLiteral("1".toCharArray(), source);
        resultDecl.type = TypeReference.baseTypeReference(TypeIds.T_int, 0);
        resultDecl.type.sourceStart = pS;
        resultDecl.type.sourceEnd = pE;
        setGeneratedBy(resultDecl.type, source);
        statements.add(resultDecl);
    }

    if (callSuper) {
        MessageSend callToSuper = new MessageSend();
        setGeneratedBy(callToSuper, source);
        callToSuper.sourceStart = pS;
        callToSuper.sourceEnd = pE;
        callToSuper.receiver = new SuperReference(pS, pE);
        setGeneratedBy(callToSuper.receiver, source);
        callToSuper.selector = "hashCode".toCharArray();
        statements.add(createResultCalculation(source, callToSuper));
    }

    for (EclipseNode field : fields) {
        TypeReference fType = getFieldType(field, fieldAccess);
        char[] dollarFieldName = ("$" + field.getName()).toCharArray();
        char[] token = fType.getLastToken();
        Expression fieldAccessor = createFieldAccessor(field, fieldAccess, source);
        if (fType.dimensions() == 0 && token != null) {
            if (Arrays.equals(TypeConstants.BOOLEAN, token)) {
                /* booleanField ? X : Y */
                IntLiteral intTrue = makeIntLiteral(String.valueOf(HandlerUtil.primeForTrue()).toCharArray(),
                        source);
                IntLiteral intFalse = makeIntLiteral(String.valueOf(HandlerUtil.primeForFalse()).toCharArray(),
                        source);
                ConditionalExpression intForBool = new ConditionalExpression(fieldAccessor, intTrue, intFalse);
                setGeneratedBy(intForBool, source);
                statements.add(createResultCalculation(source, intForBool));
            } else if (Arrays.equals(TypeConstants.LONG, token)) {
                statements.add(createLocalDeclaration(source, dollarFieldName,
                        TypeReference.baseTypeReference(TypeIds.T_long, 0), fieldAccessor));
                SingleNameReference copy1 = new SingleNameReference(dollarFieldName, p);
                setGeneratedBy(copy1, source);
                SingleNameReference copy2 = new SingleNameReference(dollarFieldName, p);
                setGeneratedBy(copy2, source);
                statements.add(createResultCalculation(source, longToIntForHashCode(copy1, copy2, source)));
            } else if (Arrays.equals(TypeConstants.FLOAT, token)) {
                /* Float.floatToIntBits(fieldName) */
                MessageSend floatToIntBits = new MessageSend();
                floatToIntBits.sourceStart = pS;
                floatToIntBits.sourceEnd = pE;
                setGeneratedBy(floatToIntBits, source);
                floatToIntBits.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA_LANG_FLOAT);
                floatToIntBits.selector = "floatToIntBits".toCharArray();
                floatToIntBits.arguments = new Expression[] { fieldAccessor };
                statements.add(createResultCalculation(source, floatToIntBits));
            } else if (Arrays.equals(TypeConstants.DOUBLE, token)) {
                /* longToIntForHashCode(Double.doubleToLongBits(fieldName)) */
                MessageSend doubleToLongBits = new MessageSend();
                doubleToLongBits.sourceStart = pS;
                doubleToLongBits.sourceEnd = pE;
                setGeneratedBy(doubleToLongBits, source);
                doubleToLongBits.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA_LANG_DOUBLE);
                doubleToLongBits.selector = "doubleToLongBits".toCharArray();
                doubleToLongBits.arguments = new Expression[] { fieldAccessor };
                statements.add(createLocalDeclaration(source, dollarFieldName,
                        TypeReference.baseTypeReference(TypeIds.T_long, 0), doubleToLongBits));
                SingleNameReference copy1 = new SingleNameReference(dollarFieldName, p);
                setGeneratedBy(copy1, source);
                SingleNameReference copy2 = new SingleNameReference(dollarFieldName, p);
                setGeneratedBy(copy2, source);
                statements.add(createResultCalculation(source, longToIntForHashCode(copy1, copy2, source)));
            } else if (BUILT_IN_TYPES.contains(new String(token))) {
                statements.add(createResultCalculation(source, fieldAccessor));
            } else /* objects */ {
                /* final java.lang.Object $fieldName = this.fieldName; */
                /* $fieldName == null ? NULL_PRIME : $fieldName.hashCode() */
                statements.add(createLocalDeclaration(source, dollarFieldName,
                        generateQualifiedTypeRef(source, TypeConstants.JAVA_LANG_OBJECT), fieldAccessor));

                SingleNameReference copy1 = new SingleNameReference(dollarFieldName, p);
                setGeneratedBy(copy1, source);
                SingleNameReference copy2 = new SingleNameReference(dollarFieldName, p);
                setGeneratedBy(copy2, source);

                MessageSend hashCodeCall = new MessageSend();
                hashCodeCall.sourceStart = pS;
                hashCodeCall.sourceEnd = pE;
                setGeneratedBy(hashCodeCall, source);
                hashCodeCall.receiver = copy1;
                hashCodeCall.selector = "hashCode".toCharArray();
                NullLiteral nullLiteral = new NullLiteral(pS, pE);
                setGeneratedBy(nullLiteral, source);
                EqualExpression objIsNull = new EqualExpression(copy2, nullLiteral, OperatorIds.EQUAL_EQUAL);
                setGeneratedBy(objIsNull, source);
                IntLiteral intMagic = makeIntLiteral(String.valueOf(HandlerUtil.primeForNull()).toCharArray(),
                        source);
                ConditionalExpression nullOrHashCode = new ConditionalExpression(objIsNull, intMagic,
                        hashCodeCall);
                nullOrHashCode.sourceStart = pS;
                nullOrHashCode.sourceEnd = pE;
                setGeneratedBy(nullOrHashCode, source);
                statements.add(createResultCalculation(source, nullOrHashCode));
            }
        } else if (fType.dimensions() > 0 && token != null) {
            /* Arrays.deepHashCode(array)  //just hashCode for simple arrays */
            MessageSend arraysHashCodeCall = new MessageSend();
            arraysHashCodeCall.sourceStart = pS;
            arraysHashCodeCall.sourceEnd = pE;
            setGeneratedBy(arraysHashCodeCall, source);
            arraysHashCodeCall.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA,
                    TypeConstants.UTIL, "Arrays".toCharArray());
            if (fType.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(token))) {
                arraysHashCodeCall.selector = "deepHashCode".toCharArray();
            } else {
                arraysHashCodeCall.selector = "hashCode".toCharArray();
            }
            arraysHashCodeCall.arguments = new Expression[] { fieldAccessor };
            statements.add(createResultCalculation(source, arraysHashCodeCall));
        }
    }

    /* return result; */ {
        SingleNameReference resultRef = new SingleNameReference(RESULT, p);
        setGeneratedBy(resultRef, source);
        ReturnStatement returnStatement = new ReturnStatement(resultRef, pS, pE);
        setGeneratedBy(returnStatement, source);
        statements.add(returnStatement);
    }
    method.statements = statements.toArray(new Statement[statements.size()]);
    return method;
}

From source file:lombok.eclipse.handlers.HandleEqualsAndHashCode.java

License:Open Source License

public MethodDeclaration createEquals(EclipseNode type, Collection<EclipseNode> fields, boolean callSuper,
        ASTNode source, FieldAccess fieldAccess, boolean needsCanEqual, List<Annotation> onParam) {
    int pS = source.sourceStart;
    int pE = source.sourceEnd;
    long p = (long) pS << 32 | pE;
    TypeDeclaration typeDecl = (TypeDeclaration) type.get();

    MethodDeclaration method = new MethodDeclaration(
            ((CompilationUnitDeclaration) type.top().get()).compilationResult);
    setGeneratedBy(method, source);//w  w  w . j  a  va2  s.  co  m
    method.modifiers = toEclipseModifier(AccessLevel.PUBLIC);
    method.returnType = TypeReference.baseTypeReference(TypeIds.T_boolean, 0);
    method.returnType.sourceStart = pS;
    method.returnType.sourceEnd = pE;
    setGeneratedBy(method.returnType, source);
    method.annotations = new Annotation[] { makeMarkerAnnotation(TypeConstants.JAVA_LANG_OVERRIDE, source) };
    method.selector = "equals".toCharArray();
    method.thrownExceptions = null;
    method.typeParameters = null;
    method.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
    method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
    method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;
    TypeReference objectRef = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT,
            new long[] { p, p, p });
    setGeneratedBy(objectRef, source);
    method.arguments = new Argument[] { new Argument(new char[] { 'o' }, 0, objectRef, Modifier.FINAL) };
    method.arguments[0].sourceStart = pS;
    method.arguments[0].sourceEnd = pE;
    if (!onParam.isEmpty())
        method.arguments[0].annotations = onParam.toArray(new Annotation[0]);
    setGeneratedBy(method.arguments[0], source);

    List<Statement> statements = new ArrayList<Statement>();

    /* if (o == this) return true; */ {
        SingleNameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
        setGeneratedBy(oRef, source);
        ThisReference thisRef = new ThisReference(pS, pE);
        setGeneratedBy(thisRef, source);
        EqualExpression otherEqualsThis = new EqualExpression(oRef, thisRef, OperatorIds.EQUAL_EQUAL);
        setGeneratedBy(otherEqualsThis, source);

        TrueLiteral trueLiteral = new TrueLiteral(pS, pE);
        setGeneratedBy(trueLiteral, source);
        ReturnStatement returnTrue = new ReturnStatement(trueLiteral, pS, pE);
        setGeneratedBy(returnTrue, source);
        IfStatement ifOtherEqualsThis = new IfStatement(otherEqualsThis, returnTrue, pS, pE);
        setGeneratedBy(ifOtherEqualsThis, source);
        statements.add(ifOtherEqualsThis);
    }

    /* if (!(o instanceof Outer.Inner.MyType) return false; */ {
        SingleNameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
        setGeneratedBy(oRef, source);

        TypeReference typeReference = createTypeReference(type, p);
        setGeneratedBy(typeReference, source);

        InstanceOfExpression instanceOf = new InstanceOfExpression(oRef, typeReference);
        instanceOf.sourceStart = pS;
        instanceOf.sourceEnd = pE;
        setGeneratedBy(instanceOf, source);

        Expression notInstanceOf = new UnaryExpression(instanceOf, OperatorIds.NOT);
        setGeneratedBy(notInstanceOf, source);

        FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
        setGeneratedBy(falseLiteral, source);

        ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
        setGeneratedBy(returnFalse, source);

        IfStatement ifNotInstanceOf = new IfStatement(notInstanceOf, returnFalse, pS, pE);
        setGeneratedBy(ifNotInstanceOf, source);
        statements.add(ifNotInstanceOf);
    }

    char[] otherName = "other".toCharArray();

    /* MyType<?> other = (MyType<?>) o; */ {
        if (!fields.isEmpty() || needsCanEqual) {
            LocalDeclaration other = new LocalDeclaration(otherName, pS, pE);
            other.modifiers |= ClassFileConstants.AccFinal;
            setGeneratedBy(other, source);
            char[] typeName = typeDecl.name;
            TypeReference targetType;
            if (typeDecl.typeParameters == null || typeDecl.typeParameters.length == 0) {
                targetType = new SingleTypeReference(typeName, p);
                setGeneratedBy(targetType, source);
                other.type = new SingleTypeReference(typeName, p);
                setGeneratedBy(other.type, source);
            } else {
                TypeReference[] typeArgs = new TypeReference[typeDecl.typeParameters.length];
                for (int i = 0; i < typeArgs.length; i++) {
                    typeArgs[i] = new Wildcard(Wildcard.UNBOUND);
                    typeArgs[i].sourceStart = pS;
                    typeArgs[i].sourceEnd = pE;
                    setGeneratedBy(typeArgs[i], source);
                }
                targetType = new ParameterizedSingleTypeReference(typeName, typeArgs, 0, p);
                setGeneratedBy(targetType, source);
                other.type = new ParameterizedSingleTypeReference(typeName, copyTypes(typeArgs, source), 0, p);
                setGeneratedBy(other.type, source);
            }
            NameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
            setGeneratedBy(oRef, source);
            other.initialization = makeCastExpression(oRef, targetType, source);
            statements.add(other);
        }
    }

    /* if (!other.canEqual((java.lang.Object) this)) return false; */ {
        if (needsCanEqual) {
            MessageSend otherCanEqual = new MessageSend();
            otherCanEqual.sourceStart = pS;
            otherCanEqual.sourceEnd = pE;
            setGeneratedBy(otherCanEqual, source);
            otherCanEqual.receiver = new SingleNameReference(otherName, p);
            setGeneratedBy(otherCanEqual.receiver, source);
            otherCanEqual.selector = "canEqual".toCharArray();

            ThisReference thisReference = new ThisReference(pS, pE);
            setGeneratedBy(thisReference, source);
            CastExpression castThisRef = makeCastExpression(thisReference,
                    generateQualifiedTypeRef(source, TypeConstants.JAVA_LANG_OBJECT), source);
            castThisRef.sourceStart = pS;
            castThisRef.sourceEnd = pE;

            otherCanEqual.arguments = new Expression[] { castThisRef };

            Expression notOtherCanEqual = new UnaryExpression(otherCanEqual, OperatorIds.NOT);
            setGeneratedBy(notOtherCanEqual, source);

            FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
            setGeneratedBy(falseLiteral, source);

            ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
            setGeneratedBy(returnFalse, source);

            IfStatement ifNotCanEqual = new IfStatement(notOtherCanEqual, returnFalse, pS, pE);
            setGeneratedBy(ifNotCanEqual, source);

            statements.add(ifNotCanEqual);
        }
    }

    /* if (!super.equals(o)) return false; */
    if (callSuper) {
        MessageSend callToSuper = new MessageSend();
        callToSuper.sourceStart = pS;
        callToSuper.sourceEnd = pE;
        setGeneratedBy(callToSuper, source);
        callToSuper.receiver = new SuperReference(pS, pE);
        setGeneratedBy(callToSuper.receiver, source);
        callToSuper.selector = "equals".toCharArray();
        SingleNameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
        setGeneratedBy(oRef, source);
        callToSuper.arguments = new Expression[] { oRef };
        Expression superNotEqual = new UnaryExpression(callToSuper, OperatorIds.NOT);
        setGeneratedBy(superNotEqual, source);
        FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
        setGeneratedBy(falseLiteral, source);
        ReturnStatement returnFalse = new ReturnStatement(falseLiteral, pS, pE);
        setGeneratedBy(returnFalse, source);
        IfStatement ifSuperEquals = new IfStatement(superNotEqual, returnFalse, pS, pE);
        setGeneratedBy(ifSuperEquals, source);
        statements.add(ifSuperEquals);
    }

    for (EclipseNode field : fields) {
        TypeReference fType = getFieldType(field, fieldAccess);
        char[] token = fType.getLastToken();
        Expression thisFieldAccessor = createFieldAccessor(field, fieldAccess, source);
        Expression otherFieldAccessor = createFieldAccessor(field, fieldAccess, source, otherName);

        if (fType.dimensions() == 0 && token != null) {
            if (Arrays.equals(TypeConstants.FLOAT, token)) {
                statements.add(generateCompareFloatOrDouble(thisFieldAccessor, otherFieldAccessor,
                        "Float".toCharArray(), source));
            } else if (Arrays.equals(TypeConstants.DOUBLE, token)) {
                statements.add(generateCompareFloatOrDouble(thisFieldAccessor, otherFieldAccessor,
                        "Double".toCharArray(), source));
            } else if (BUILT_IN_TYPES.contains(new String(token))) {
                EqualExpression fieldsNotEqual = new EqualExpression(thisFieldAccessor, otherFieldAccessor,
                        OperatorIds.NOT_EQUAL);
                setGeneratedBy(fieldsNotEqual, source);
                FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
                setGeneratedBy(falseLiteral, source);
                ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
                setGeneratedBy(returnStatement, source);
                IfStatement ifStatement = new IfStatement(fieldsNotEqual, returnStatement, pS, pE);
                setGeneratedBy(ifStatement, source);
                statements.add(ifStatement);
            } else /* objects */ {
                /* final java.lang.Object this$fieldName = this.fieldName; */
                /* final java.lang.Object other$fieldName = other.fieldName; */
                /* if (this$fieldName == null ? other$fieldName != null : !this$fieldName.equals(other$fieldName)) return false;; */
                char[] thisDollarFieldName = ("this$" + field.getName()).toCharArray();
                char[] otherDollarFieldName = ("other$" + field.getName()).toCharArray();

                statements.add(createLocalDeclaration(source, thisDollarFieldName,
                        generateQualifiedTypeRef(source, TypeConstants.JAVA_LANG_OBJECT), thisFieldAccessor));
                statements.add(createLocalDeclaration(source, otherDollarFieldName,
                        generateQualifiedTypeRef(source, TypeConstants.JAVA_LANG_OBJECT), otherFieldAccessor));

                SingleNameReference this1 = new SingleNameReference(thisDollarFieldName, p);
                setGeneratedBy(this1, source);
                SingleNameReference this2 = new SingleNameReference(thisDollarFieldName, p);
                setGeneratedBy(this2, source);
                SingleNameReference other1 = new SingleNameReference(otherDollarFieldName, p);
                setGeneratedBy(other1, source);
                SingleNameReference other2 = new SingleNameReference(otherDollarFieldName, p);
                setGeneratedBy(other2, source);

                NullLiteral nullLiteral = new NullLiteral(pS, pE);
                setGeneratedBy(nullLiteral, source);
                EqualExpression fieldIsNull = new EqualExpression(this1, nullLiteral, OperatorIds.EQUAL_EQUAL);
                nullLiteral = new NullLiteral(pS, pE);
                setGeneratedBy(nullLiteral, source);
                EqualExpression otherFieldIsntNull = new EqualExpression(other1, nullLiteral,
                        OperatorIds.NOT_EQUAL);
                MessageSend equalsCall = new MessageSend();
                equalsCall.sourceStart = pS;
                equalsCall.sourceEnd = pE;
                setGeneratedBy(equalsCall, source);
                equalsCall.receiver = this2;
                equalsCall.selector = "equals".toCharArray();
                equalsCall.arguments = new Expression[] { other2 };
                UnaryExpression fieldsNotEqual = new UnaryExpression(equalsCall, OperatorIds.NOT);
                fieldsNotEqual.sourceStart = pS;
                fieldsNotEqual.sourceEnd = pE;
                setGeneratedBy(fieldsNotEqual, source);
                ConditionalExpression fullEquals = new ConditionalExpression(fieldIsNull, otherFieldIsntNull,
                        fieldsNotEqual);
                fullEquals.sourceStart = pS;
                fullEquals.sourceEnd = pE;
                setGeneratedBy(fullEquals, source);
                FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
                setGeneratedBy(falseLiteral, source);
                ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
                setGeneratedBy(returnStatement, source);
                IfStatement ifStatement = new IfStatement(fullEquals, returnStatement, pS, pE);
                setGeneratedBy(ifStatement, source);
                statements.add(ifStatement);
            }
        } else if (fType.dimensions() > 0 && token != null) {
            MessageSend arraysEqualCall = new MessageSend();
            arraysEqualCall.sourceStart = pS;
            arraysEqualCall.sourceEnd = pE;
            setGeneratedBy(arraysEqualCall, source);
            arraysEqualCall.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA, TypeConstants.UTIL,
                    "Arrays".toCharArray());
            if (fType.dimensions() > 1 || !BUILT_IN_TYPES.contains(new String(token))) {
                arraysEqualCall.selector = "deepEquals".toCharArray();
            } else {
                arraysEqualCall.selector = "equals".toCharArray();
            }
            arraysEqualCall.arguments = new Expression[] { thisFieldAccessor, otherFieldAccessor };
            UnaryExpression arraysNotEqual = new UnaryExpression(arraysEqualCall, OperatorIds.NOT);
            arraysNotEqual.sourceStart = pS;
            arraysNotEqual.sourceEnd = pE;
            setGeneratedBy(arraysNotEqual, source);
            FalseLiteral falseLiteral = new FalseLiteral(pS, pE);
            setGeneratedBy(falseLiteral, source);
            ReturnStatement returnStatement = new ReturnStatement(falseLiteral, pS, pE);
            setGeneratedBy(returnStatement, source);
            IfStatement ifStatement = new IfStatement(arraysNotEqual, returnStatement, pS, pE);
            setGeneratedBy(ifStatement, source);
            statements.add(ifStatement);
        }
    }

    /* return true; */ {
        TrueLiteral trueLiteral = new TrueLiteral(pS, pE);
        setGeneratedBy(trueLiteral, source);
        ReturnStatement returnStatement = new ReturnStatement(trueLiteral, pS, pE);
        setGeneratedBy(returnStatement, source);
        statements.add(returnStatement);
    }
    method.statements = statements.toArray(new Statement[statements.size()]);
    return method;
}

From source file:lombok.eclipse.handlers.HandleNonNull.java

License:Open Source License

public char[] returnVarNameIfNullCheck(Statement stat) {
    if (!(stat instanceof IfStatement))
        return null;

    /* Check that the if's statement is a throw statement, possibly in a block. */ {
        Statement then = ((IfStatement) stat).thenStatement;
        if (then instanceof Block) {
            Statement[] blockStatements = ((Block) then).statements;
            if (blockStatements == null || blockStatements.length == 0)
                return null;
            then = blockStatements[0];/*from ww w  . jav a2s  .c  o  m*/
        }

        if (!(then instanceof ThrowStatement))
            return null;
    }

    /* Check that the if's conditional is like 'x == null'. Return from this method (don't generate
       a nullcheck) if 'x' is equal to our own variable's name: There's already a nullcheck here. */ {
        Expression cond = ((IfStatement) stat).condition;
        if (!(cond instanceof EqualExpression))
            return null;
        EqualExpression bin = (EqualExpression) cond;
        int operatorId = ((bin.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT);
        if (operatorId != OperatorIds.EQUAL_EQUAL)
            return null;
        if (!(bin.left instanceof SingleNameReference))
            return null;
        if (!(bin.right instanceof NullLiteral))
            return null;
        return ((SingleNameReference) bin.left).token;
    }
}

From source file:lombok.eclipse.handlers.HandleSuperBuilder.java

License:Open Source License

private MessageSend createSetterCallWithInstanceValue(BuilderFieldData bfd, EclipseNode type, ASTNode source) {
    char[] setterName = bfd.name;
    MessageSend ms = new MessageSend();
    Expression[] tgt = new Expression[bfd.singularData == null ? 1 : 2];

    if (bfd.obtainVia == null || !bfd.obtainVia.field().isEmpty()) {
        char[] fieldName = bfd.obtainVia == null ? bfd.rawName : bfd.obtainVia.field().toCharArray();
        for (int i = 0; i < tgt.length; i++) {
            FieldReference fr = new FieldReference(fieldName, 0);
            fr.receiver = new SingleNameReference(INSTANCE_VARIABLE_NAME, 0);
            tgt[i] = fr;/*from  ww w  .  j a v a  2  s. com*/
        }
    } else {
        String obtainName = bfd.obtainVia.method();
        boolean obtainIsStatic = bfd.obtainVia.isStatic();
        for (int i = 0; i < tgt.length; i++) {
            MessageSend obtainExpr = new MessageSend();
            obtainExpr.receiver = obtainIsStatic ? new SingleNameReference(type.getName().toCharArray(), 0)
                    : new SingleNameReference(INSTANCE_VARIABLE_NAME, 0);
            obtainExpr.selector = obtainName.toCharArray();
            if (obtainIsStatic)
                obtainExpr.arguments = new Expression[] { new SingleNameReference(INSTANCE_VARIABLE_NAME, 0) };
            tgt[i] = obtainExpr;
        }
    }
    if (bfd.singularData == null) {
        ms.arguments = tgt;
    } else {
        Expression ifNull = new EqualExpression(tgt[0], new NullLiteral(0, 0), OperatorIds.EQUAL_EQUAL);
        MessageSend emptyList = new MessageSend();
        emptyList.receiver = generateQualifiedNameRef(source, TypeConstants.JAVA, TypeConstants.UTIL,
                "Collections".toCharArray());
        emptyList.selector = EMPTY_LIST;
        ms.arguments = new Expression[] { new ConditionalExpression(ifNull, emptyList, tgt[1]) };
    }
    ms.receiver = new SingleNameReference(BUILDER_VARIABLE_NAME, 0);
    ms.selector = setterName;
    return ms;
}

From source file:lombok.eclipse.handlers.HandleUpsortable.java

License:Open Source License

static MethodDeclaration createSetter(TypeDeclaration parent, EclipseNode fieldNode, String name,
        boolean shouldReturnThis, int modifier, EclipseNode sourceNode, List<Annotation> onMethod,
        List<Annotation> onParam) {
    FieldDeclaration field = (FieldDeclaration) fieldNode.get();
    ASTNode source = sourceNode.get();/*from  w w  w.ja  v a  2s  .c o  m*/
    int pS = source.sourceStart, pE = source.sourceEnd;
    long p = (long) pS << 32 | pE;
    MethodDeclaration method = new MethodDeclaration(parent.compilationResult);
    method.modifiers = modifier;
    if (shouldReturnThis) {
        method.returnType = cloneSelfType(fieldNode, source);
    }

    if (method.returnType == null) {
        method.returnType = TypeReference.baseTypeReference(TypeIds.T_void, 0);
        method.returnType.sourceStart = pS;
        method.returnType.sourceEnd = pE;
        shouldReturnThis = false;
    }
    Annotation[] deprecated = null;
    if (isFieldDeprecated(fieldNode)) {
        deprecated = new Annotation[] { generateDeprecatedAnnotation(source) };
    }
    method.annotations = copyAnnotations(source, onMethod.toArray(new Annotation[0]), deprecated);
    Argument param = new Argument(field.name, p, copyType(field.type, source), Modifier.FINAL);
    param.sourceStart = pS;
    param.sourceEnd = pE;
    method.arguments = new Argument[] { param };
    method.selector = name.toCharArray();
    method.binding = null;
    method.thrownExceptions = null;
    method.typeParameters = null;
    method.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
    Expression fieldRef = createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
    NameReference fieldNameRef = new SingleNameReference(field.name, p);
    Assignment assignment = new Assignment(fieldRef, fieldNameRef, (int) p);
    assignment.sourceStart = pS;
    assignment.sourceEnd = assignment.statementEnd = pE;
    method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
    method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;

    Annotation[] nonNulls = findAnnotations(field, NON_NULL_PATTERN);
    Annotation[] nullables = findAnnotations(field, NULLABLE_PATTERN);
    List<Statement> statements = new ArrayList<Statement>(5);
    // if (nonNulls.length == 0) {
    // statements.add(assignment);
    // } else {
    // Statement nullCheck = generateNullCheck(field, sourceNode);
    // if (nullCheck != null) statements.add(nullCheck);
    // statements.add(assignment);
    // }
    //
    // if (shouldReturnThis) {
    // ThisReference thisRef = new ThisReference(pS, pE);
    // ReturnStatement returnThis = new ReturnStatement(thisRef, pS, pE);
    // statements.add(returnThis);
    // }

    /*
     * if (this.$field == $field) return;
     */ {
        Expression lfRef = createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source);
        setGeneratedBy(lfRef, source);
        NameReference fRef = new SingleNameReference(field.name, p);
        setGeneratedBy(lfRef, source);
        setGeneratedBy(fRef, source);
        EqualExpression otherEqualsThis = new EqualExpression(lfRef, fRef, OperatorIds.EQUAL_EQUAL);
        setGeneratedBy(otherEqualsThis, source);

        TrueLiteral trueLiteral = new TrueLiteral(pS, pE);
        setGeneratedBy(trueLiteral, source);
        ReturnStatement returnTrue = new ReturnStatement(null, pS, pE);
        setGeneratedBy(returnTrue, source);
        IfStatement ifOtherEqualsThis = new IfStatement(otherEqualsThis, returnTrue, pS, pE);
        setGeneratedBy(ifOtherEqualsThis, source);
        statements.add(ifOtherEqualsThis);
    }

    /* String fname = this.getClass().getDeclaredField("$field").getName(); */
    //      {
    //         // Left side
    //         LocalDeclaration fieldClass = new LocalDeclaration("fname".toCharArray(), pS, pE);
    //         fieldClass.modifiers |= Modifier.FINAL;
    //         fieldClass.type = new SingleTypeReference("String".toCharArray(), p);
    //         setGeneratedBy(fieldClass, source);
    //         // Right side - first call
    //         MessageSend getClass = new MessageSend();
    //         getClass.sourceStart = pS;
    //         getClass.sourceEnd = pE;
    //         setGeneratedBy(getClass, source);
    //         ThisReference thisReference = new ThisReference(pS, pE);
    //         setGeneratedBy(thisReference, source);
    //         getClass.receiver = thisReference;
    //         getClass.selector = "getClass".toCharArray();
    //         // Right side - second call
    //         MessageSend getDeclaredField = new MessageSend();
    //         getDeclaredField.sourceStart = pS;
    //         getDeclaredField.sourceEnd = pE;
    //         setGeneratedBy(getDeclaredField, source);
    //         getDeclaredField.receiver = getClass;
    //         getDeclaredField.selector = "getDeclaredField".toCharArray();
    //         // Arguments of the call
    //         getDeclaredField.arguments = new Expression[] {new StringLiteral(field.name, pS, pE, 0)};
    //         // Third call
    //         MessageSend getName = new MessageSend();
    //         getName.sourceStart = pS;
    //         getName.sourceEnd = pE;
    //         setGeneratedBy(getName, source);
    //         getName.receiver = getDeclaredField;
    //         getName.selector = "getName".toCharArray();
    //         // Assign right to left
    //         fieldClass.initialization = getName;
    //         statements.add(fieldClass);
    //      }
    //      
    //      
    //      /* Set<UpsortableSet> set = UpsortableSets.GLOBAL_UPSORTABLE
    //               .get(this.getClass().getName() + "." + field.getName());*/
    //      {
    //         //left hand of the assignment
    //         LocalDeclaration fieldClass = new LocalDeclaration("sets".toCharArray(), pS, pE);
    //         fieldClass.modifiers |= Modifier.FINAL;
    //         fieldClass.type = new SingleTypeReference("java.util.Set".toCharArray(), p);
    //         //Righthand
    //         MessageSend get = new MessageSend();
    //         get.sourceStart = pS;
    //         get.sourceEnd = pE;
    //         setGeneratedBy(get, source);
    //         FieldReference ref = new FieldReference("lombok.upsortable.UpsortableSets.GLOBAL_UPSORTABLE", pos)
    //         setGeneratedBy(thisReference, source);
    //         getClass.receiver = thisReference;
    //         getClass.selector = "getClass".toCharArray();
    //         //Assignment
    //      }
    method.statements = statements.toArray(new Statement[0]);
    param.annotations = copyAnnotations(source, nonNulls, nullables, onParam.toArray(new Annotation[0]));

    method.traverse(new SetGeneratedByVisitor(source), parent.scope);
    return method;
}

From source file:lombok.eclipse.handlers.HandleWither.java

License:Open Source License

public MethodDeclaration createWither(TypeDeclaration parent, EclipseNode fieldNode, String name, int modifier,
        EclipseNode sourceNode, List<Annotation> onMethod, List<Annotation> onParam) {
    ASTNode source = sourceNode.get();/* w  w  w  .  j  a  v  a 2 s.c o  m*/
    if (name == null)
        return null;
    FieldDeclaration field = (FieldDeclaration) fieldNode.get();
    int pS = source.sourceStart, pE = source.sourceEnd;
    long p = (long) pS << 32 | pE;
    MethodDeclaration method = new MethodDeclaration(parent.compilationResult);
    method.modifiers = modifier;
    method.returnType = cloneSelfType(fieldNode, source);
    if (method.returnType == null)
        return null;

    Annotation[] deprecated = null;
    if (isFieldDeprecated(fieldNode)) {
        deprecated = new Annotation[] { generateDeprecatedAnnotation(source) };
    }
    method.annotations = copyAnnotations(source, onMethod.toArray(new Annotation[0]), deprecated);
    Argument param = new Argument(field.name, p, copyType(field.type, source), Modifier.FINAL);
    param.sourceStart = pS;
    param.sourceEnd = pE;
    method.arguments = new Argument[] { param };
    method.selector = name.toCharArray();
    method.binding = null;
    method.thrownExceptions = null;
    method.typeParameters = null;
    method.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;

    List<Expression> args = new ArrayList<Expression>();
    for (EclipseNode child : fieldNode.up().down()) {
        if (child.getKind() != Kind.FIELD)
            continue;
        FieldDeclaration childDecl = (FieldDeclaration) child.get();
        // Skip fields that start with $
        if (childDecl.name != null && childDecl.name.length > 0 && childDecl.name[0] == '$')
            continue;
        long fieldFlags = childDecl.modifiers;
        // Skip static fields.
        if ((fieldFlags & ClassFileConstants.AccStatic) != 0)
            continue;
        // Skip initialized final fields.
        if (((fieldFlags & ClassFileConstants.AccFinal) != 0) && childDecl.initialization != null)
            continue;
        if (child.get() == fieldNode.get()) {
            args.add(new SingleNameReference(field.name, p));
        } else {
            args.add(createFieldAccessor(child, FieldAccess.ALWAYS_FIELD, source));
        }
    }

    AllocationExpression constructorCall = new AllocationExpression();
    constructorCall.arguments = args.toArray(new Expression[0]);
    constructorCall.type = cloneSelfType(fieldNode, source);

    Expression identityCheck = new EqualExpression(
            createFieldAccessor(fieldNode, FieldAccess.ALWAYS_FIELD, source),
            new SingleNameReference(field.name, p), OperatorIds.EQUAL_EQUAL);
    ThisReference thisRef = new ThisReference(pS, pE);
    Expression conditional = new ConditionalExpression(identityCheck, thisRef, constructorCall);
    Statement returnStatement = new ReturnStatement(conditional, pS, pE);
    method.bodyStart = method.declarationSourceStart = method.sourceStart = source.sourceStart;
    method.bodyEnd = method.declarationSourceEnd = method.sourceEnd = source.sourceEnd;

    Annotation[] nonNulls = findAnnotations(field, NON_NULL_PATTERN);
    Annotation[] nullables = findAnnotations(field, NULLABLE_PATTERN);
    List<Statement> statements = new ArrayList<Statement>(5);
    if (nonNulls.length > 0) {
        Statement nullCheck = generateNullCheck(field, sourceNode);
        if (nullCheck != null)
            statements.add(nullCheck);
    }
    statements.add(returnStatement);

    method.statements = statements.toArray(new Statement[0]);

    param.annotations = copyAnnotations(source, nonNulls, nullables, onParam.toArray(new Annotation[0]));

    method.traverse(new SetGeneratedByVisitor(source), parent.scope);
    return method;
}

From source file:lombok.eclipse.handlers.NonNullHandler.java

License:Open Source License

private char[] returnVarNameIfNullCheck(Statement stat) {
    if (!(stat instanceof IfStatement))
        return null;

    /* Check that the if's statement is a throw statement, possibly in a block. */ {
        Statement then = ((IfStatement) stat).thenStatement;
        if (then instanceof Block) {
            Statement[] blockStatements = ((Block) then).statements;
            if (blockStatements == null || blockStatements.length == 0)
                return null;
            then = blockStatements[0];/* www  .j  a v a 2 s .  c  o m*/
        }

        if (!(then instanceof ThrowStatement))
            return null;
    }

    /* Check that the if's conditional is like 'x == null'. Return from this method (don't generate
       a nullcheck) if 'x' is equal to our own variable's name: There's already a nullcheck here. */ {
        Expression cond = ((IfStatement) stat).condition;
        if (!(cond instanceof EqualExpression))
            return null;
        EqualExpression bin = (EqualExpression) cond;
        int operatorId = ((bin.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT);
        if (operatorId != OperatorIds.EQUAL_EQUAL)
            return null;
        if (!(bin.left instanceof SingleNameReference))
            return null;
        if (!(bin.right instanceof NullLiteral))
            return null;
        return ((SingleNameReference) bin.left).token;
    }
}

From source file:lombok.eclipse.handlers.PKG.java

License:Open Source License

static Statement generateNullCheck(AbstractVariableDeclaration variable, ASTNode source) {
    int pS = source.sourceStart, pE = source.sourceEnd;
    long p = (long) pS << 32 | pE;

    if (isPrimitive(variable.type))
        return null;
    AllocationExpression exception = new AllocationExpression();
    Eclipse.setGeneratedBy(exception, source);
    exception.type = new QualifiedTypeReference(fromQualifiedName("java.lang.NullPointerException"),
            new long[] { p, p, p });
    Eclipse.setGeneratedBy(exception.type, source);
    exception.arguments = new Expression[] { new StringLiteral(variable.name, pS, pE, 0) };
    Eclipse.setGeneratedBy(exception.arguments[0], source);
    ThrowStatement throwStatement = new ThrowStatement(exception, pS, pE);
    Eclipse.setGeneratedBy(throwStatement, source);

    SingleNameReference varName = new SingleNameReference(variable.name, p);
    Eclipse.setGeneratedBy(varName, source);
    NullLiteral nullLiteral = new NullLiteral(pS, pE);
    Eclipse.setGeneratedBy(nullLiteral, source);
    EqualExpression equalExpression = new EqualExpression(varName, nullLiteral, OperatorIds.EQUAL_EQUAL);
    equalExpression.sourceStart = pS;//  w ww .j  a va 2 s . c  om
    equalExpression.sourceEnd = pE;
    Eclipse.setGeneratedBy(equalExpression, source);
    IfStatement ifStatement = new IfStatement(equalExpression, throwStatement, 0, 0);
    Eclipse.setGeneratedBy(ifStatement, source);
    return ifStatement;
}