Attachment #130963 for bug #225533

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 225533
Collapse All | Expand All




    <!-- ACTUAL CHANGES BEGIN HERE: -->

    <changes>
         <change id="LambdaEnhancements">
             <api name="general"/>
             <summary>Added several methods to support Java 8 features.</summary>
             <version major="0" minor="112"/>
             <date day="13" month="2" year="2013"/>
             <author login="jlahoda"/>
            <compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible"/>
             <description>
                 Added several new methods to support Java 8 features. Namely: <code>ElementUtilities.isEffectivelyFinal</code>,
                 <code>TreeMaker.TypeAnnotation</code>, <code>TreeMaker.LambdaExpression</code>,
                 <code>TreeMaker.MemberReference</code> and <code>TypeUtilities.getDescriptorType</code>.
             </description>
             <issue number="225533"/>
        </change>
         <change id="SourceUtils-getDependentRoots">
             <api name="general"/>
             <summary>Added overloaded method <code>SourceUtils.getDependentRoots</code>.</summary>




import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.TypeParameterElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.TypeKind;

                case DECLARED:
                case UNION:
                    TypeElement te = (TypeElement)((DeclaredType)type).asElement();
                    if (te == null) break;
                    for (Element member : elements.getAllMembers(te)) {
                        if (acceptor == null || acceptor.accept(member, type)) {
                            if (!isHidden(member, members, elements, types))

        }
        return false;
    }
    
    /** Check whether the given variable is effectively final or final.
     * 
     * @param e variable to check for effectively final status
     * @return true if the given variable is effectively final or final
     * @since 0.112
     */
    public boolean isEffectivelyFinal(VariableElement e) {
        return (((Symbol) e).flags() & (Flags.EFFECTIVELY_FINAL | Flags.FINAL)) != 0;
    };
    
    // private implementation --------------------------------------------------






import com.sun.source.tree.*;
import org.netbeans.modules.java.source.parsing.FileObjects;
import org.openide.filesystems.FileObject;
import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
import static com.sun.source.tree.Tree.*;

import com.sun.source.util.SourcePositions;

        return delegate.Annotation(type, arguments);
    }
    
    /** 
     * Creates a new type AnnotationTree.
     *
     * @param type the annotation type.
     * @param arguments the arguments for this annotation, or an empty list.
     * @see com.sun.source.tree.AnnotationTree
     * @since 0.112
     */
    public AnnotationTree TypeAnnotation(Tree type, List<? extends ExpressionTree> arguments) {
        return delegate.TypeAnnotation(type, arguments);
    }
    
    /**
     * Creates a new ArrayAccessTree.
     *

    public LabeledStatementTree LabeledStatement(CharSequence label, StatementTree statement) {
        return delegate.LabeledStatement(label, statement);
    }

    /**Creates a new LambdaExpressionTree
     * 
     * @param parameters the lambda's formal arguments
     * @param body the lambda's body
     * @return the LambdaExpressionTree
     * @since 0.112
     */
    public LambdaExpressionTree LambdaExpression(List<? extends VariableTree> parameters, Tree body) {
        return delegate.LambdaExpression(parameters, body);
    }

    /**
     * Creates a new LiteralTree.  Only literals which are wrappers for 
     * primitive types (Integer, Boolean, etc.) and String instances can

        return delegate.Literal(value);
    }
    
    /**Creates a new MemberReferenceTree.
     * 
     * @param refMode the desired {@link ReferenceMode reference mode}
     * @param expression the class (or expression), from which a member is to be referenced
     * @param name the name of the referenced member
     * @param typeArguments the reference's type arguments
     * @return the MemberReferenceTree
     * @since 0.112
     */
    public MemberReferenceTree MemberReference(ReferenceMode refMode, ExpressionTree expression, CharSequence name, List<? extends ExpressionTree> typeArguments) {
        return delegate.MemberReference(refMode, name, expression, typeArguments);
    }
    
    /**
     * Creates a new MemberSelectTree.  A MemberSelectTree consists of an
     * expression and an identifier.  Valid expressions include things like

     * <tt>aLabel</tt> argument. Throws <tt>IllegalArgumentException</tt> if
     * <tt>node</tt>'s kind is invalid. Valid <tt>node</tt>'s kinds are:<br>
     * BREAK, CLASS, CONTINUE, IDENTIFIER, LABELED_STATEMENT,
     * MEMBER_SELECT, METHOD, TYPE_PARAMETER, VARIABLE, MEMBER_REFERENCE (since 0.112).<p>
     *
     * Consider you want to change name of  method <tt>fooMet</tt> to
     * <tt>fooMethod</tt>:

                        );
                return clone;
            }
            case MEMBER_REFERENCE: {
                MemberReferenceTree t = (MemberReferenceTree) node;
                N clone = (N) MemberReference(
                        t.getMode(),
                        t.getQualifierExpression(),
                        aLabel,
                        t.getTypeArguments()
                        );
                return clone;
            }
            case METHOD: {
                MethodTree t = (MethodTree) node;
                N clone = (N) Method(

        }

    }

    /**
     * Appends specified element <tt>parameter</tt>
     * to the end of parameters list.
     *
     * @param  method        lambda expression tree containing parameters list.
     * @param  parameter     element to be appended to parameters list.
     * @return lambda expression tree with modified parameters.
     * @since 0.112
     */
    public LambdaExpressionTree addLambdaParameter(LambdaExpressionTree method, VariableTree parameter) {
        return delegate.addLambdaParameter(method, parameter);
    }
    
    /**
     * Inserts the specified element <tt>parameter</tt> 
     * at the specified position in parameters list.
     *
     * @param  method lambda expression tree containing parameters list.
     * @param  index  index at which the specified elements is to be inserted.
     * @param  parameter   element to be inserted to parameters list.
     * @return lambda expression  tree with modified parameters.
     *
     * @throws    IndexOutOfBoundsException if the index is out of range
     *		  (index &lt; 0 || index &gt; size()).
     * @since 0.112
     */
    public LambdaExpressionTree insertLambdaParameter(LambdaExpressionTree method, int index, VariableTree parameter) {
        return delegate.insertLambdaParameter(method, index, parameter);
    }
    
    /**
     * Removes the first occurrence in parameters list of the specified 
     * elements. If this list do not contain the element, it is
     * unchanged.
     *
     * @param   method lambda expression tree containing parameters list.
     * @param   parameter   element to be removed from this list, if present.
     * @return  lambda expression tree with modified parameters and type parameters.
     * @since 0.112
     */
    public LambdaExpressionTree removeLambdaParameter(LambdaExpressionTree method, VariableTree parameter) {
        return delegate.removeLambdaParameter(method, parameter);
    }
    
    /**
     * Removes the element at the specified position in parameters list.
     * Returns the modified lambda expression tree.
     *
     * @param   method lambda expression tree containing parameters list.
     * @param   index  the index of the element to be removed.
     * @return  method tree with modified parameters.
     * 
     * @throws IndexOutOfBoundsException if the index is out of range (index
     *            &lt; 0 || index &gt;= size()).
     * @since 0.112
     */
    public LambdaExpressionTree removeLambdaParameter(LambdaExpressionTree method, int index) {
        return delegate.removeLambdaParameter(method, index);
    }
    
    /**Creates a new lambda expression as a copy of the given lambda expression
     * with the specified body.
     * 
     * @param method the source lambda expression
     * @param newBody the new body
     * @return new lambda expression tree with the new body
     * @since 0.112
     */
    public LambdaExpressionTree setLambdaBody(LambdaExpressionTree method, Tree newBody) {
        return delegate.setLambdaBody(method, newBody);
    }
}




import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.Type.ClassType;
import com.sun.tools.javac.code.Type.TypeVar;
import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.code.Types;
import com.sun.tools.javac.code.Types.DefaultTypeVisitor;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Names;
import java.util.ArrayList;
import java.util.Collections;

import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ErrorType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.ReferenceType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;

                    typeMirrors.add(create(alternative, map));
                }
                break;
            case INTERSECTION:
                typeMirrors = new ArrayList<TypeMirrorHandle<? extends TypeMirror>>();
                for (TypeMirror alternative : ((IntersectionType) tm).getBounds()) {
                    typeMirrors.add(create(alternative, map));
                }
                break;
            default:
                throw new IllegalArgumentException("Currently unsupported TypeKind: " + tm.getKind());
        }

                t = Types.instance(info.impl.getJavacTask().getContext());
                Type lub = t.lub(resolvedAlternatives);

                if (!lub.hasTag(TypeTag.CLASS)) return null;

                return (T) new Type.UnionClassType((ClassType) lub, resolvedAlternatives);
            case INTERSECTION:
                ListBuffer<Type> resolvedBounds = new ListBuffer<Type>();
                for (TypeMirrorHandle alternative : typeMirrors) {
                    TypeMirror resolvedAlternative = alternative.resolve(info, map);
                    if (resolvedAlternative == null) {
                        return null;
                    }
                    resolvedBounds = resolvedBounds.append((Type) resolvedAlternative);
                }
                
                t = Types.instance(info.impl.getJavacTask().getContext());
                
                return (T) t.makeCompoundType(resolvedBounds.toList());
            default:
                throw new IllegalStateException("Internal error: unknown TypeHandle kind: " + kind);
        }

        private Type delegate = null;
        
        public PlaceholderType() {
            super(TypeTag.UNKNOWN, null);
        }       
    }
    




import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ErrorType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;

        return Types.instance(info.impl.getJavacTask().getContext()).subst((Type)type, l1, l2);
    }

    /**
     * Find the type of the method descriptor associated to the functional interface.
     * 
     * @param origin functional interface type
     * @return associated method descriptor type or <code>null</code> if the <code>origin</code> is not a functional interface.
     * @since 0.112
     */
    public ExecutableType getDescriptorType(DeclaredType origin) {
        Types types = Types.instance(info.impl.getJavacTask().getContext());
        if (types.isFunctionalInterface(((Type)origin).tsym)) {
            Type dt = types.findDescriptorType((Type)origin);
            if (dt != null && dt.getKind() == TypeKind.EXECUTABLE) {
                return (ExecutableType)dt;
            }
        }
        return null;
    }
    
   /**Get textual representation of the given type.
     *
     * @param type to print
     * @param options allows to specify various adjustments to the output text

            }
            return DEFAULT_VALUE;
        }

        @Override
        public StringBuilder visitUnknown(TypeMirror t, Boolean p) {
            return DEFAULT_VALUE.append("<unknown>");
        }

    }
}




package org.netbeans.modules.java.source;

import com.sun.javadoc.ClassDoc;
import com.sun.source.util.TreePath;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Kinds;
import com.sun.tools.javac.code.Symbol.ClassSymbol;

import com.sun.tools.javac.code.Symbol.TypeSymbol;
import com.sun.tools.javac.code.Symbol.VarSymbol;
import com.sun.tools.javac.tree.JCTree.JCClassDecl;
import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import com.sun.tools.javac.util.Position;
import com.sun.tools.javadoc.AnnotationTypeDocImpl;
import com.sun.tools.javadoc.AnnotationTypeElementDocImpl;
import com.sun.tools.javadoc.ClassDocImpl;

    }
    
    @Override
    protected void makeClassDoc(ClassSymbol clazz, TreePath treePath) {
        ClassDocImpl result = classMap.get(clazz);
        if (result != null) {
            if (treePath != null) result.setTreePath(treePath);
            return;
        }
        if (isAnnotationType((JCClassDecl)treePath.getLeaf())) {	// flags of clazz may not yet be set
            result = new JavadocAnnotation(this, clazz, treePath);
        } else {
            result = new JavadocClass(this, clazz, treePath);
        }
        classMap.put(clazz, result);
    }

    }

    @Override
    protected void makeFieldDoc(VarSymbol var, TreePath treePath) {
        FieldDocImpl result = fieldMap.get(var);
        if (result != null) {
            if (treePath != null) result.setTreePath(treePath);
        } else {
            result = new JavadocField(this, var, treePath);
            fieldMap.put(var, result);
        }
    }

    }
    
    @Override
    protected void makeMethodDoc(MethodSymbol meth, TreePath treePath) {
        MethodDocImpl result = (MethodDocImpl)methodMap.get(meth);
        if (result != null) {
            if (treePath != null) result.setTreePath(treePath);
        } else {
            result = new JavadocMethod(this, meth, treePath);
            methodMap.put(meth, result);
        }
    }

    }

    @Override
    protected void makeConstructorDoc(MethodSymbol meth, TreePath treePath) {
        ConstructorDocImpl result = (ConstructorDocImpl)methodMap.get(meth);
        if (result != null) {
            if (treePath != null) result.setTreePath(treePath);
        } else {
            result = new JavadocConstructor(this, meth, treePath);
            methodMap.put(meth, result);
        }
    }

    }
    
    @Override
    protected void makeAnnotationTypeElementDoc(MethodSymbol meth, TreePath treePath) {
        AnnotationTypeElementDocImpl result = (AnnotationTypeElementDocImpl)methodMap.get(meth);
        if (result != null) {
            if (treePath != null) result.setTreePath(treePath);
        } else {
            result = new JavadocAnnotationTypeElement(this, meth, treePath);
            methodMap.put(meth, result);
        }
    }

    private class JavadocClass extends ClassDocImpl implements ElementHolder {
        
        private JavadocClass(DocEnv env, ClassSymbol sym) {
            super(env, sym);
        }
        
        private JavadocClass(DocEnv env, ClassSymbol sym, TreePath treePath) {
            super(env, sym, treePath);
        }
        
        @Override

    private class JavadocAnnotation extends AnnotationTypeDocImpl implements ElementHolder {
        
        private JavadocAnnotation(DocEnv env, ClassSymbol sym) {
            super(env, sym);
        }
        
        private JavadocAnnotation(DocEnv env, ClassSymbol sym, TreePath treePath) {
            super(env, sym, treePath);
        }
        
        @Override

    private class JavadocField extends FieldDocImpl implements ElementHolder {

        private JavadocField(DocEnv env, VarSymbol sym) {
            super(env, sym);
        }
        
        private JavadocField(DocEnv env, VarSymbol sym, TreePath treePath) {
            super(env, sym, treePath);
        }

        @Override

    private class JavadocMethod extends MethodDocImpl implements ElementHolder {

        private JavadocMethod(DocEnv env, MethodSymbol sym) {
            super(env, sym);
        }
        
        private JavadocMethod(DocEnv env, MethodSymbol sym, TreePath treePath) {
            super(env, sym, treePath);
        }

        @Override

    private class JavadocConstructor extends ConstructorDocImpl implements ElementHolder {

        private JavadocConstructor(DocEnv env, MethodSymbol sym) {
            super(env, sym);
        }
        
        private JavadocConstructor(DocEnv env, MethodSymbol sym, TreePath treePath) {
            super(env, sym, treePath);
        }

        @Override

    private class JavadocAnnotationTypeElement extends AnnotationTypeElementDocImpl implements ElementHolder {

        private JavadocAnnotationTypeElement(DocEnv env, MethodSymbol sym) {
            super(env, sym);
        }
        
        private JavadocAnnotationTypeElement(DocEnv env, MethodSymbol sym, TreePath treePath) {
            super(env, sym, treePath);
        }

        @Override

Lines 200-206 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/PostFlowAnalysis.java (-1 / +1 lines)
200	Symbol c = meth.owner;	200	Symbol c = meth.owner;
201	if (c.hasOuterInstance()) {	201	if (c.hasOuterInstance()) {
202	checkThis = false;	202	checkThis = false;
203	if (tree.meth.getTag() != JCTree.SELECT && ((c.owner.kind & (Kinds.MTH \| Kinds.VAR)) != 0 \|\| methName == names._this)) {	203	if (tree.meth.getTag() != JCTree.Tag.SELECT && ((c.owner.kind & (Kinds.MTH \| Kinds.VAR)) != 0 \|\| methName == names._this)) {
204	checkThis(tree.meth.pos(), c.type.getEnclosingType().tsym);	204	checkThis(tree.meth.pos(), c.type.getEnclosingType().tsym);
205	}	205	}
206	}	206	}




import com.sun.tools.javac.util.CouplingAbort;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.Log;
import com.sun.tools.javac.util.Log.DiscardDiagnosticHandler;
import java.awt.EventQueue;
import java.io.File;
import java.io.FileOutputStream;

                    List<JCTree> prev = null;
                    for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                        scan(l.head);
                        if (l.head.getTag() == JCTree.Tag.BLOCK) {
                            if (prev != null)
                                prev.tail = l.tail;
                            else

    public static void dumpSymFile(JavaFileManager jfm, JavacTaskImpl jti, ClassSymbol clazz) throws IOException {
        Log log = Log.instance(jti.getContext());
        JavaFileObject prevLogTo = log.useSource(null);
        DiscardDiagnosticHandler discardDiagnosticHandler = new Log.DiscardDiagnosticHandler(log);
        log.suppressErrorsAndWarnings = true;
        try {
            String binaryName = null;
            String surl = null;

            LOGGER.log(Level.INFO, "InvalidSourcePath reported when writing sym file for class: {0}", clazz.flatname); // NOI18N
        } finally {
            jfm.handleOption("output-root", Collections.singletonList("").iterator()); //NOI18N
            log.popDiagnosticHandler(discardDiagnosticHandler);
            log.useSource(prevLogTo);
        }
    }




import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import javax.lang.model.util.Types;
import org.netbeans.api.java.source.*;
import com.sun.tools.javac.code.Scope;
import com.sun.tools.javac.code.Symbol;
import com.sun.tools.javac.code.Symbol.ClassSymbol;
import com.sun.tools.javac.code.Symbol.MethodSymbol;
import com.sun.tools.javac.code.Symbol.TypeSymbol;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.model.JavacTypes;
import com.sun.tools.javac.util.Context;
import javax.lang.model.element.*;

        if ((m.flags() & Flags.STATIC) == 0) {
            ClassSymbol owner = (ClassSymbol) m.owner;
            for (Type sup = jctypes.supertype(m.owner.type);
                 sup.hasTag(TypeTag.CLASS);
                 sup = jctypes.supertype(sup)) {
                for (Scope.Entry e = sup.tsym.members().lookup(m.name);
                     e.scope != null; e = e.next()) {

	// Check if this method overrides a deprecated method. 
	TypeSymbol owner = sym.enclClass();
	for (Type sup = jctypes.supertype(owner.type);
	     sup.hasTag(TypeTag.CLASS);
	     sup = jctypes.supertype(sup)) {
	    for (Scope.Entry e = sup.tsym.members().lookup(sym.name);
		 e.scope != null; e = e.next()) {

    public ExecutableElement getOverriddenMethod(ExecutableElement method) {
        MethodSymbol m = (MethodSymbol)method;
	ClassSymbol origin = (ClassSymbol)m.owner;
	for (Type t = jctypes.supertype(origin.type); t.hasTag(TypeTag.CLASS); t = jctypes.supertype(t)) {
	    TypeSymbol c = t.tsym;
	    Scope.Entry e = c.members().lookup(m.name);
	    while (e.scope != null) {





package org.netbeans.modules.java.source.builder;

import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
import com.sun.tools.javac.code.Type.ErrorType;
import com.sun.tools.javac.model.JavacElements;
import com.sun.tools.javac.util.Names;

import com.sun.tools.javac.code.Symbol;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.Type.WildcardType;
import com.sun.tools.javac.code.TypeTags;
import com.sun.tools.javac.jvm.ClassReader;
import com.sun.tools.javac.model.JavacTypes;
import com.sun.tools.javac.tree.JCTree;

import org.netbeans.api.annotations.common.NonNull;
import static org.netbeans.modules.java.source.save.PositionEstimator.*;
import static com.sun.tools.javac.code.Flags.*;
import com.sun.tools.javac.code.TypeTag;

/**
 * Factory for creating new com.sun.source.tree instances.

        return make.at(NOPOS).Annotation((JCTree)type, lb.toList());
    }

    public AnnotationTree TypeAnnotation(Tree type, List<? extends ExpressionTree> arguments) {
        ListBuffer<JCExpression> lb = new ListBuffer<JCExpression>();
        for (ExpressionTree t : arguments)
            lb.append((JCExpression)t);
        return make.at(NOPOS).TypeAnnotation((JCTree)type, lb.toList());
    }
    
    public AnnotatedTypeTree AnnotatedType(List<? extends AnnotationTree> annotations, ExpressionTree underlyingType) {
        ListBuffer<JCAnnotation> lb = new ListBuffer<JCAnnotation>();
        for (AnnotationTree t : annotations)
            lb.append((JCAnnotation)t);
        return make.at(NOPOS).AnnotatedType(lb.toList(), (JCExpression)underlyingType);
    }

    public ArrayAccessTree ArrayAccess(ExpressionTree array, ExpressionTree index) {
        return make.at(NOPOS).Indexed((JCExpression)array, (JCExpression)index);
    }

    }
    
    public BinaryTree Binary(Kind operator, ExpressionTree left, ExpressionTree right) {
        final Tag op;
        switch (operator) {
            case MULTIPLY: op = JCTree.Tag.MUL; break;
            case DIVIDE: op = JCTree.Tag.DIV; break;
            case REMAINDER: op = JCTree.Tag.MOD; break;
            case PLUS: op = JCTree.Tag.PLUS; break;
            case MINUS: op = JCTree.Tag.MINUS; break;
            case LEFT_SHIFT: op = JCTree.Tag.SL; break;
            case RIGHT_SHIFT: op = JCTree.Tag.SR; break;
            case UNSIGNED_RIGHT_SHIFT: op = JCTree.Tag.USR; break;
            case LESS_THAN: op = JCTree.Tag.LT; break;
            case GREATER_THAN: op = JCTree.Tag.GT; break;
            case LESS_THAN_EQUAL: op = JCTree.Tag.LE; break;
            case GREATER_THAN_EQUAL: op = JCTree.Tag.GE; break;
            case EQUAL_TO: op = JCTree.Tag.EQ; break;
            case NOT_EQUAL_TO: op = JCTree.Tag.NE; break;
            case AND: op = JCTree.Tag.BITAND; break;
            case XOR: op = JCTree.Tag.BITXOR; break;
            case OR: op = JCTree.Tag.BITOR; break;
            case CONDITIONAL_AND: op = JCTree.Tag.AND; break;
            case CONDITIONAL_OR: op = JCTree.Tag.OR; break;
            default:
                throw new IllegalArgumentException("Illegal binary operator: " + operator);
        }

    public CompoundAssignmentTree CompoundAssignment(Kind operator, 
                                                     ExpressionTree variable, 
                                                     ExpressionTree expression) {
        final Tag op;
        switch (operator) {
            case MULTIPLY_ASSIGNMENT: op = JCTree.Tag.MUL_ASG; break;
            case DIVIDE_ASSIGNMENT: op = JCTree.Tag.DIV_ASG; break;
            case REMAINDER_ASSIGNMENT: op = JCTree.Tag.MOD_ASG; break;
            case PLUS_ASSIGNMENT: op = JCTree.Tag.PLUS_ASG; break;
            case MINUS_ASSIGNMENT: op = JCTree.Tag.MINUS_ASG; break;
            case LEFT_SHIFT_ASSIGNMENT: op = JCTree.Tag.SL_ASG; break;
            case RIGHT_SHIFT_ASSIGNMENT: op = JCTree.Tag.SR_ASG; break;
            case UNSIGNED_RIGHT_SHIFT_ASSIGNMENT: op = JCTree.Tag.USR_ASG; break;
            case AND_ASSIGNMENT: op = JCTree.Tag.BITAND_ASG; break;
            case XOR_ASSIGNMENT: op = JCTree.Tag.BITXOR_ASG; break;
            case OR_ASSIGNMENT: op = JCTree.Tag.BITOR_ASG; break;
            default:
                throw new IllegalArgumentException("Illegal binary operator: " + operator);
        }

        return make.at(NOPOS).TypeTest((JCExpression)expression, (JCTree)type);
    }
    
    public IntersectionTypeTree IntersectionType(List<? extends Tree> bounds) {
        ListBuffer<JCExpression> jcbounds = new ListBuffer<JCExpression>();
        for (Tree t : bounds)
            jcbounds.append((JCExpression)t);
        return make.at(NOPOS).TypeIntersection(jcbounds.toList());
    }
    
    public LabeledStatementTree LabeledStatement(CharSequence label, StatementTree statement) {
        return make.at(NOPOS).Labelled(names.fromString(label.toString()), (JCStatement)statement);
    }
    
    public LambdaExpressionTree LambdaExpression(List<? extends VariableTree> parameters, Tree body) {
        ListBuffer<JCVariableDecl> params = new ListBuffer<JCVariableDecl>();
        for (Tree t : parameters)
            params.append((JCVariableDecl)t);
        return make.at(NOPOS).Lambda(params.toList(), (JCTree) body);
    }

    public LiteralTree Literal(Object value) {
        try {
            if (value instanceof Boolean)  // workaround for javac issue 6504896
                return make.at(NOPOS).Literal(TypeTag.BOOLEAN, value == Boolean.FALSE ? 0 : 1);
            if (value instanceof Character) // looks like world championship in workarounds here ;-)
                return make.at(NOPOS).Literal(TypeTag.CHAR, Integer.valueOf((Character) value));
            if (value instanceof Byte) // #119143: Crystal ball no. 4
                return make.at(NOPOS).Literal(TypeTag.INT, ((Byte) value).intValue());
            if (value instanceof Short)
                return make.at(NOPOS).Literal(TypeTag.INT, ((Short) value).intValue());
            // workaround for making NULL_LITERAL kind.
            if (value == null) {
                return make.at(NOPOS).Literal(TypeTag.BOT, value);
            }
            return make.at(NOPOS).Literal(value);
        } catch (AssertionError e) {

    public MethodTree Method(ExecutableElement element, BlockTree body) {
        return make.at(NOPOS).MethodDef((Symbol.MethodSymbol)element, (JCBlock)body);
    }

    public MemberReferenceTree MemberReference(ReferenceMode refMode, CharSequence name, ExpressionTree expression, List<? extends ExpressionTree> typeArguments) {
        ListBuffer<JCExpression> targs;
        
        if (typeArguments != null) {
            targs = new ListBuffer<JCExpression>();
            for (ExpressionTree t : typeArguments)
                targs.append((JCExpression)t);
        } else {
            targs = null;
        }
        
        return make.at(NOPOS).Reference(refMode, names.fromString(name.toString()), (JCExpression) expression, targs != null ? targs.toList() : null);
    }
    
    public ModifiersTree Modifiers(Set<Modifier> flagset, List<? extends AnnotationTree> annotations) {
        return Modifiers(modifiersToFlags(flagset), annotations);

    }
    
    public PrimitiveTypeTree PrimitiveType(TypeKind typekind) {
        final TypeTag typetag;
        switch (typekind) {
            case BOOLEAN:
                typetag = TypeTag.BOOLEAN;
                break;
            case BYTE:
                typetag = TypeTag.BYTE;
                break;
            case SHORT:
                typetag = TypeTag.SHORT;
                break;
            case INT:
                typetag = TypeTag.INT;
                break;
            case LONG:
                typetag = TypeTag.LONG;
                break;
            case CHAR:
                typetag = TypeTag.CHAR;
                break;
            case FLOAT:
                typetag = TypeTag.FLOAT;
                break;
            case DOUBLE:
                typetag = TypeTag.DOUBLE;
                break;
            case VOID:
                typetag = TypeTag.VOID;
                break;
            default:
                throw new AssertionError("unknown primitive type " + typekind);

                tp = make.at(NOPOS).TypeArray((JCExpression) Type(((ArrayType) type).getComponentType()));
                break;
            case NULL:
                tp = make.at(NOPOS).Literal(TypeTag.BOT, null);
                break;
            case ERROR:
                tp = make.at(NOPOS).Ident(((ErrorType) type).tsym.name);

    }
    
    public UnaryTree Unary(Kind operator, ExpressionTree arg) {
        final Tag op;
        switch (operator) {
            case POSTFIX_INCREMENT: op = JCTree.Tag.POSTINC; break;
            case POSTFIX_DECREMENT: op = JCTree.Tag.POSTDEC; break;
            case PREFIX_INCREMENT: op = JCTree.Tag.PREINC; break;
            case PREFIX_DECREMENT: op = JCTree.Tag.PREDEC; break;
            case UNARY_PLUS: op = JCTree.Tag.POS; break;
            case UNARY_MINUS: op = JCTree.Tag.NEG; break;
            case BITWISE_COMPLEMENT: op = JCTree.Tag.COMPL; break;
            case LOGICAL_COMPLEMENT: op = JCTree.Tag.NOT; break;
            default:
                throw new IllegalArgumentException("Illegal unary operator: " + operator);
        }

                throw new IllegalArgumentException("Unknown wildcard bound " + kind);
        }
        TypeBoundKind tbk = make.at(NOPOS).TypeBoundKind(boundKind);
        return make.at(NOPOS).Wildcard(tbk, (JCExpression)type);
    }
    
    ////////////////////////////////////// makers modification suggested by Tom

    }

    private AnnotationTree modifyAnnotationAttrValue(AnnotationTree annotation, int index, ExpressionTree attrValue, Operation op) {
        AnnotationTree copy = annotation.getKind() == Kind.ANNOTATION
                ? Annotation(annotation.getAnnotationType(), c(annotation.getArguments(), index, attrValue, op))
                : TypeAnnotation(annotation.getAnnotationType(), c(annotation.getArguments(), index, attrValue, op));
        );
        return copy;
    }
    

        return copy;
    }
    
    public LambdaExpressionTree addLambdaParameter(LambdaExpressionTree method, VariableTree parameter) {
        return modifyLambdaParameter(method, -1, parameter, Operation.ADD);
    }

    public LambdaExpressionTree insertLambdaParameter(LambdaExpressionTree method, int index, VariableTree parameter) {
        return modifyLambdaParameter(method, index, parameter, Operation.ADD);
    }
    
    public LambdaExpressionTree removeLambdaParameter(LambdaExpressionTree method, VariableTree parameter) {
        return modifyLambdaParameter(method, -1, parameter, Operation.REMOVE);
    }

    public LambdaExpressionTree removeLambdaParameter(LambdaExpressionTree method, int index) {
        return modifyLambdaParameter(method, index, null, Operation.REMOVE);
    }
    
    private LambdaExpressionTree modifyLambdaParameter(LambdaExpressionTree method, int index, VariableTree parameter, Operation op) {
        LambdaExpressionTree copy = LambdaExpression(
                c(method.getParameters(), index, parameter, op),
                method.getBody()
        );
        return copy;
    }
    
    public LambdaExpressionTree setLambdaBody(LambdaExpressionTree method, Tree newBody) {
        return LambdaExpression(method.getParameters(),newBody);
    }
    
    private <E extends Tree> List<E> c(List<? extends E> originalList, int index, E item, Operation operation) {
        List<E> copy = new ArrayList<E>(originalList);
        switch (operation) {





    static void setErrors(Context context, CompileTuple active, DiagnosticListenerImpl errors) {
        if (!active.virtual) {
            Iterable<Diagnostic<? extends JavaFileObject>> filteredErrorsList = Iterators.filter(errors.getDiagnostics(active.jfo), new FilterOutJDK7AndLaterWarnings());
            ErrorsCache.setErrors(context.getRootURI(), active.indexable, filteredErrorsList, active.aptGenerated ? ERROR_CONVERTOR_NO_BADGE : ERROR_CONVERTOR);
        }
    }

        return result;
    }

    private static final Set<String> JDK7AndLaterWarnings = new HashSet<String>(Arrays.asList(
            "compiler.warn.diamond.redundant.args", 
            "compiler.warn.diamond.redundant.args.1",
            "compiler.note.potential.lambda.found"));

    private static class FilterOutJDK7AndLaterWarnings implements Comparable<Diagnostic<? extends JavaFileObject>> {
        @Override public int compareTo(Diagnostic<? extends JavaFileObject> o) {
            return JDK7AndLaterWarnings.contains(o.getCode()) ? 0 : -1;
        }
    }
    




import com.sun.tools.javac.code.Symbol.ClassSymbol;
import com.sun.tools.javac.code.Symtab;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.code.Types;
import com.sun.tools.javac.comp.AttrContext;
import com.sun.tools.javac.comp.Enter;

                            public void visitClassDef(JCClassDecl node) {
                                if (node.sym != null) {
                                    Type st = ts.supertype(node.sym.type);
                                    if (st.hasTag(TypeTag.CLASS)) {
                                        ClassSymbol c = st.tsym.outermostClass();
                                        CompileTuple u = jfo2tuples.get(c.sourcefile);
                                        if (u != null && !previous.finishedFiles.contains(u.indexable) && !u.indexable.equals(activeIndexable)) {

                    public void visitClassDef(JCClassDecl node) {
                        if (node.sym != null) {
                            Type st = types.supertype(node.sym.type);
                            if (st.hasTag(TypeTag.CLASS)) {
                                ClassSymbol c = st.tsym.outermostClass();
                                Env<AttrContext> stEnv = enter.getEnv(c);
                                if (stEnv != null && env != stEnv) {

Lines 238-244 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/indexing/SuperOnePassCompileWorker.java (-1 / +1 lines)
238	}	238	}
239	List<TypeElement> activeTypes = new ArrayList<TypeElement>();	239	List<TypeElement> activeTypes = new ArrayList<TypeElement>();
240	for (Tree tree : unit.getKey().getTypeDecls()) {	240	for (Tree tree : unit.getKey().getTypeDecls()) {
241	if (tree instanceof JCTree && ((JCTree)tree).getTag() == JCTree.CLASSDEF) {	241	if (tree instanceof JCTree && ((JCTree)tree).getTag() == JCTree.Tag.CLASSDEF) {
242	ClassSymbol sym = ((JCClassDecl)tree).sym;	242	ClassSymbol sym = ((JCClassDecl)tree).sym;
243	if (sym != null)	243	if (sym != null)
244	activeTypes.add(sym);	244	activeTypes.add(sym);

Lines 53-58 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/parsing/JavacParser.java (-12 / +15 lines)
53	import com.sun.tools.javac.api.JavacTaskImpl;	53	import com.sun.tools.javac.api.JavacTaskImpl;
54	import com.sun.tools.javac.api.JavacTool;	54	import com.sun.tools.javac.api.JavacTool;
55	import com.sun.tools.javac.api.JavacTrees;	55	import com.sun.tools.javac.api.JavacTrees;
		56	import com.sun.tools.javac.parser.LazyDocCommentTable;
		57	import com.sun.tools.javac.parser.Tokens.Comment;
		58	import com.sun.tools.javac.tree.EndPosTable;
56	import com.sun.tools.javac.tree.JCTree;	59	import com.sun.tools.javac.tree.JCTree;
57	import com.sun.tools.javac.tree.JCTree.JCBlock;	60	import com.sun.tools.javac.tree.JCTree.JCBlock;
58	import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;	61	import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
Lines 97-103 Link Here
97	import javax.swing.text.JTextComponent;	100	import javax.swing.text.JTextComponent;
98	import javax.tools.Diagnostic;	101	import javax.tools.Diagnostic;
99	import javax.tools.DiagnosticListener;	102	import javax.tools.DiagnosticListener;
100	import javax.tools.JavaCompiler;
101	import javax.tools.JavaFileObject;	103	import javax.tools.JavaFileObject;
102	import org.netbeans.api.annotations.common.NonNull;	104	import org.netbeans.api.annotations.common.NonNull;
103	import org.netbeans.api.annotations.common.NullAllowed;	105	import org.netbeans.api.annotations.common.NullAllowed;
Lines 717-723 Link Here
717	JavacTaskImpl javacTask = createJavacTask(cpInfo, diagnosticListener, sourceLevel, false, oraculum, dcc, parser == null ? null : new DefaultCancelService(parser), APTUtils.get(root));	719	JavacTaskImpl javacTask = createJavacTask(cpInfo, diagnosticListener, sourceLevel, false, oraculum, dcc, parser == null ? null : new DefaultCancelService(parser), APTUtils.get(root));
718	Context context = javacTask.getContext();	720	Context context = javacTask.getContext();
719	TreeLoader.preRegister(context, cpInfo, detached);	721	TreeLoader.preRegister(context, cpInfo, detached);
720	com.sun.tools.javac.main.JavaCompiler.instance(context).keepComments = true;
721	return javacTask;	722	return javacTask;
722	}	723	}
723		724
Lines 735-740 Link Here
735	if (!backgroundCompilation) {	736	if (!backgroundCompilation) {
736	options.add("-Xjcov"); //NOI18N, Make the compiler store end positions	737	options.add("-Xjcov"); //NOI18N, Make the compiler store end positions
737	options.add("-XDallowStringFolding=false"); //NOI18N	738	options.add("-XDallowStringFolding=false"); //NOI18N
		739	options.add("-XDkeepComments=true"); //NOI18N
738	assert options.add("-XDdev") \|\| true; //NOI18N	740	assert options.add("-XDdev") \|\| true; //NOI18N
739	} else {	741	} else {
740	options.add("-XDbackgroundCompilation"); //NOI18N	742	options.add("-XDbackgroundCompilation"); //NOI18N
Lines 783-796 Link Here
783	options.add("-proc:none"); // NOI18N, Disable annotation processors	785	options.add("-proc:none"); // NOI18N, Disable annotation processors
784	}	786	}
785		787
786	JavaCompiler tool = JavacTool.create();	788	Context context = new Context();
787	JavacTaskImpl task = (JavacTaskImpl)tool.getTask(null,	789	//need to preregister the Messages here, because the getTask below requires Log instance:
		790	Messager.preRegister(context, null, DEV_NULL, DEV_NULL, DEV_NULL);
		791	JavacTaskImpl task = (JavacTaskImpl)JavacTool.create().getTask(null,
788	ClasspathInfoAccessor.getINSTANCE().getFileManager(cpInfo),	792	ClasspathInfoAccessor.getINSTANCE().getFileManager(cpInfo),
789	diagnosticListener, options, null, Collections.<JavaFileObject>emptySet());	793	diagnosticListener, options, null, Collections.<JavaFileObject>emptySet(),
		794	context);
790	if (aptEnabled) {	795	if (aptEnabled) {
791	task.setProcessors(processors);	796	task.setProcessors(processors);
792	}	797	}
793	Context context = task.getContext();
794	NBClassReader.preRegister(context, !backgroundCompilation);	798	NBClassReader.preRegister(context, !backgroundCompilation);
795	if (cnih != null) {	799	if (cnih != null) {
796	context.put(ClassNamesForFileOraculum.class, cnih);	800	context.put(ClassNamesForFileOraculum.class, cnih);
Lines 801-807 Link Here
801	if (cancelService != null) {	805	if (cancelService != null) {
802	DefaultCancelService.preRegister(context, cancelService);	806	DefaultCancelService.preRegister(context, cancelService);
803	}	807	}
804	Messager.preRegister(context, null, DEV_NULL, DEV_NULL, DEV_NULL);
805	NBAttr.preRegister(context);	808	NBAttr.preRegister(context);
806	NBClassWriter.preRegister(context);	809	NBClassWriter.preRegister(context);
807	NBParserFactory.preRegister(context);	810	NBParserFactory.preRegister(context);
Lines 1000-1006 Link Here
1000	assert dl instanceof CompilationInfoImpl.DiagnosticListenerImpl;	1003	assert dl instanceof CompilationInfoImpl.DiagnosticListenerImpl;
1001	((CompilationInfoImpl.DiagnosticListenerImpl)dl).startPartialReparse(origStartPos, origEndPos);	1004	((CompilationInfoImpl.DiagnosticListenerImpl)dl).startPartialReparse(origStartPos, origEndPos);
1002	long start = System.currentTimeMillis();	1005	long start = System.currentTimeMillis();
1003	Map<JCTree,String> docComments = new HashMap<JCTree, String>();	1006	Map<JCTree,LazyDocCommentTable.Entry> docComments = new HashMap<JCTree, LazyDocCommentTable.Entry>();
1004	block = pr.reparseMethodBody(cu, orig, newBody, firstInner, docComments);	1007	block = pr.reparseMethodBody(cu, orig, newBody, firstInner, docComments);
1005	if (LOGGER.isLoggable(Level.FINER)) {	1008	if (LOGGER.isLoggable(Level.FINER)) {
1006	LOGGER.log(Level.FINER, "Reparsed method in: {0}", fo); //NOI18N	1009	LOGGER.log(Level.FINER, "Reparsed method in: {0}", fo); //NOI18N
Lines 1015-1029 Link Here
1015	}	1018	}
1016	return false;	1019	return false;
1017	}	1020	}
1018	((JCTree.JCCompilationUnit)cu).docComments.keySet().removeAll(fav.docOwners);	1021	((LazyDocCommentTable) ((JCTree.JCCompilationUnit)cu).docComments).table.keySet().removeAll(fav.docOwners);
1019	((JCTree.JCCompilationUnit)cu).docComments.putAll(docComments);	1022	((LazyDocCommentTable) ((JCTree.JCCompilationUnit)cu).docComments).table.putAll(docComments);
1020	long end = System.currentTimeMillis();	1023	long end = System.currentTimeMillis();
1021	if (fo != null) {	1024	if (fo != null) {
1022	logTime (fo,Phase.PARSED,(end-start));	1025	logTime (fo,Phase.PARSED,(end-start));
1023	}	1026	}
1024	final int newEndPos = (int) jt.getSourcePositions().getEndPosition(cu, block);	1027	final int newEndPos = (int) jt.getSourcePositions().getEndPosition(cu, block);
1025	final int delta = newEndPos - origEndPos;	1028	final int delta = newEndPos - origEndPos;
1026	final Map<JCTree,Integer> endPos = ((JCCompilationUnit)cu).endPositions;	1029	final EndPosTable endPos = ((JCCompilationUnit)cu).endPositions;
1027	final TranslatePositionsVisitor tpv = new TranslatePositionsVisitor(orig, endPos, delta);	1030	final TranslatePositionsVisitor tpv = new TranslatePositionsVisitor(orig, endPos, delta);
1028	tpv.scan(cu, null);	1031	tpv.scan(cu, null);
1029	((JCMethodDecl)orig).body = block;	1032	((JCMethodDecl)orig).body = block;
Lines 1060-1066 Link Here
1060	//fix CompilationUnitTree.getLineMap:	1063	//fix CompilationUnitTree.getLineMap:
1061	long startM = System.currentTimeMillis();	1064	long startM = System.currentTimeMillis();
1062	char[] chars = snapshot.getText().toString().toCharArray();	1065	char[] chars = snapshot.getText().toString().toCharArray();
1063	((LineMapImpl) cu.getLineMap()).build(chars, chars.length, '\0');	1066	((LineMapImpl) cu.getLineMap()).build(chars, chars.length);
1064	LOGGER.log(Level.FINER, "Rebuilding LineMap took: {0}", System.currentTimeMillis() - startM);	1067	LOGGER.log(Level.FINER, "Rebuilding LineMap took: {0}", System.currentTimeMillis() - startM);
1065		1068
1066	((CompilationInfoImpl.DiagnosticListenerImpl)dl).endPartialReparse (delta);	1069	((CompilationInfoImpl.DiagnosticListenerImpl)dl).endPartialReparse (delta);




import com.sun.source.tree.MethodTree;
import com.sun.source.tree.Tree;
import com.sun.source.util.TreeScanner;
import com.sun.tools.javac.tree.EndPosTable;
import com.sun.tools.javac.tree.JCTree;
import org.netbeans.lib.nbjavac.services.NBParserFactory.NBJavacParser.EndPosTableImpl;

/**
 * Helper visitor for partial reparse.

class TranslatePositionsVisitor extends TreeScanner<Void,Void> {

    private final MethodTree changedMethod;
    private final EndPosTable endPos;
    private final int delta;
    boolean active;
    boolean inMethod;

    public TranslatePositionsVisitor (final MethodTree changedMethod, final EndPosTable endPos, final int delta) {
        assert changedMethod != null;
        assert endPos != null;
        this.changedMethod = changedMethod;

        }
        Void result = super.scan(node, p);            
        if (inMethod && node != null) {
            endPos.replaceTree((JCTree) node, null);//remove
        }
        if (active && node != null) {
            Integer pos = endPos.replaceTree((JCTree) node, null);//remove
            if (pos != null) {
                int newPos;
                if (pos < 0) {

                else {
                    newPos = pos+delta;
                }
                ((EndPosTableImpl) endPos).storeEnd((JCTree)node,newPos);
            }                
        }
        return result;

        }
        return null;
    }
    
    
}





import com.sun.source.tree.ClassTree;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.Tree;
import static com.sun.source.tree.Tree.*;

import com.sun.tools.javac.code.*;
import static com.sun.tools.javac.code.Flags.*;
import com.sun.tools.javac.code.Symbol.*;
import static com.sun.tools.javac.code.TypeTags.*;
import com.sun.tools.javac.main.JavaCompiler;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.JCTree.*;

import org.netbeans.modules.java.source.parsing.JavacParser;
import org.netbeans.modules.java.source.save.CasualDiff;
import org.netbeans.modules.java.source.save.DiffContext;
import static org.netbeans.modules.java.source.save.PositionEstimator.*;
import org.netbeans.modules.java.source.save.Reformatter;
import org.netbeans.modules.java.source.transform.FieldGroupTree;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;

        printPackage(tree.pid);
        List<JCTree> l = tree.defs;
        ArrayList<JCImport> imports = new ArrayList<JCImport>();
        while (l.nonEmpty() && l.head.getTag() == JCTree.Tag.IMPORT){
            imports.add((JCImport) l.head);
            l = l.tail;
        }

                print(tree.vartype);
            }
        }
        if (tree.vartype != null) //should also check the flags?
            needSpace();
        if (!ERROR.contentEquals(tree.name))
            print(tree.name);
        if (tree.init != null) {

            print(' ');
        int col = out.col;
	if (tree.init.nonEmpty()) {
	    if (tree.init.head.getTag() == JCTree.Tag.VARDEF) {
		printNoParenExpr(tree.init.head);
		for (List<? extends JCTree> l = tree.init.tail; l.nonEmpty(); l = l.tail) {
		    JCVariableDecl vdef = (JCVariableDecl) l.head;

    }

    @Override
    public void visitLambda(JCLambda that) {
	print("(");
        wrapTrees(that.params, WrapStyle.WRAP_NEVER, out.col);
        print(") -> ");
        if (that.body.getKind() == Kind.BLOCK) {
            printStat(that.body);
        } else {
            printExpr(that.body, TreeInfo.notExpression);
        }
    }

    @Override
    public void visitSwitch(JCSwitch tree) {
	print("switch");
        print(cs.spaceBeforeSwitchParen() ? " (" : "(");

    }

    public void printMethodSelect(JCMethodInvocation tree) {
        if (tree.meth.getTag() == JCTree.Tag.SELECT) {
            JCFieldAccess left = (JCFieldAccess)tree.meth;
            printExpr(left.selected);
            print('.');
            if (left.selected.getTag() == JCTree.Tag.APPLY) {
                switch(cs.wrapChainedMethodCalls()) {
                case WRAP_IF_LONG:
                    int rm = cs.getRightMargin();

	    print("new ");
	    int n = tree.elems != null ? 1 : 0;
	    JCTree elemtype = tree.elemtype;
	    while (elemtype.getTag() == JCTree.Tag.TYPEARRAY) {
		n++;
		elemtype = ((JCArrayTypeTree) elemtype).elemtype;
	    }

	printExpr(tree.lhs, TreeInfo.assignopPrec + 1);
	if (cs.spaceAroundAssignOps())
            print(' ');
	print(treeinfo.operatorName(tree.getTag().noAssignOp()));
        print('=');
	int rm = cs.getRightMargin();
        switch(cs.wrapAssignOps()) {

    public void visitUnary(JCUnary tree) {
	int ownprec = TreeInfo.opPrec(tree.getTag());
	Name opname = treeinfo.operatorName(tree.getTag());
	if (tree.getTag().ordinal() <= JCTree.Tag.PREDEC.ordinal()) { //XXX: comparing ordinals!
            if (cs.spaceAroundUnaryOps()) {
                needSpace();
                print(opname);
                print(' ');
            } else {
                print(opname);
                if (   (tree.getTag() == JCTree.Tag.POS && (tree.arg.getTag() == JCTree.Tag.POS || tree.arg.getTag() == JCTree.Tag.PREINC))
                    || (tree.getTag() == JCTree.Tag.NEG && (tree.arg.getTag() == JCTree.Tag.NEG || tree.arg.getTag() == JCTree.Tag.PREDEC))) {
                    print(' ');
                }
            }

            print(' ');
	print(opname);
        boolean needsSpace =    cs.spaceAroundBinaryOps()
                             || (tree.getTag() == JCTree.Tag.PLUS  && (tree.rhs.getTag() == JCTree.Tag.POS || tree.rhs.getTag() == JCTree.Tag.PREINC))
                             || (tree.getTag() == JCTree.Tag.MINUS && (tree.rhs.getTag() == JCTree.Tag.NEG || tree.rhs.getTag() == JCTree.Tag.PREDEC));
	int rm = cs.getRightMargin();
        switch(cs.wrapBinaryOps()) {
        case WRAP_IF_LONG:


    @Override
    public void visitTypeIdent(JCPrimitiveTypeTree tree) {
	print(tree.typetag.name().toLowerCase());
    }

    @Override

    }

    @Override
    public void visitReference(JCMemberReference tree) {
        printExpr(tree.expr);
        print("::");
        if (tree.typeargs != null && !tree.typeargs.isEmpty()) {
            print("<");
            printExprs(tree.typeargs);
            print(">");
        }
        if (tree.getMode() == ReferenceMode.INVOKE) print(tree.name);
        else print("new");
    }

    @Override
    public void visitLetExpr(LetExpr tree) {
	print("(let " + tree.defs + " in " + tree.expr + ")");
    }

                blankLines(tree, true);
	    printPrecedingComments(tree, !member);
            printExpr(tree, TreeInfo.notExpression);
	    int tag = tree.getTag().ordinal();//XXX: comparing ordinals!!!
	    if(JCTree.Tag.APPLY.ordinal()<=tag && tag<=JCTree.Tag.MOD_ASG.ordinal()) print(';');
            printTrailingComments(tree, !member);
            blankLines(tree, false);
	}


    public Name fullName(JCTree tree) {
	switch (tree.getTag()) {
	case IDENT:
	    return ((JCIdent) tree).name;
	case SELECT:
            JCFieldAccess sel = (JCFieldAccess)tree;
	    Name sname = fullName(sel.selected);
	    return sname != null && sname.getByteLength() > 0 ? sname.append('.', sel.name) : sel.name;


    /** Is the given tree an enumerator definition? */
    private static boolean isEnumerator(JCTree tree) {
        return tree.getTag() == JCTree.Tag.VARDEF && (((JCVariableDecl) tree).mods.flags & ENUM) != 0;
    }

    private String replace(String a,String b) {




import com.sun.tools.javac.tree.TreeInfo;

import static com.sun.tools.javac.code.Flags.*;
import static com.sun.tools.javac.code.TypeTags.*;

/** Estimate the printed width of a tree
 */

	if (tree.elemtype != null) {
	    width+=4;
	    JCTree elemtype = tree.elemtype;
	    while (elemtype.getTag() == JCTree.Tag.TYPEARRAY) {
		width+=2;
		elemtype = ((JCArrayTypeTree) elemtype).elemtype;
	    }

    public void visitAssignop(JCAssignOp tree) {
	open(prec, TreeInfo.assignopPrec);
	width+=3;
	width(treeinfo.operatorName(tree.getTag()));
	width(tree.lhs, TreeInfo.assignopPrec + 1);
	width(tree.rhs, TreeInfo.assignopPrec);
    }

    }

    public void visitTypeIdent(JCPrimitiveTypeTree tree) {
	width(tree.typetag.name().toLowerCase());
    }

    public void visitTypeArray(JCArrayTypeTree tree) {




        return bounds[1];
    }

    private String operatorName(Tag tag) {
        // dummy instance, just to access a public method which should be static
        return new Pretty(null, false).operatorName(tag);
    }

        copyTo(localPointer, bounds[1]);
        return bounds[1];
    }
    
    protected int diffMemberReference(JCMemberReference oldT, JCMemberReference newT, int[] bounds) {
        int localPointer = bounds[0];
        int[] exprBounds = getBounds(oldT.expr);
        copyTo(localPointer, exprBounds[0]);
        localPointer = diffTree(oldT.expr, newT.expr, exprBounds);
        tokenSequence.move(exprBounds[1]);
        moveToSrcRelevant(tokenSequence, Direction.FORWARD);
        if (tokenSequence.token() != null && tokenSequence.token().id() == JavaTokenId.COLONCOLON) {
            moveToSrcRelevant(tokenSequence, Direction.FORWARD);
            copyTo(localPointer, localPointer = tokenSequence.offset());
        }
        com.sun.tools.javac.util.List<JCExpression> oldTypePar = oldT.typeargs != null ? oldT.typeargs : com.sun.tools.javac.util.List.<JCExpression>nil();
        com.sun.tools.javac.util.List<JCExpression> newTypePar = newT.typeargs != null ? newT.typeargs : com.sun.tools.javac.util.List.<JCExpression>nil();
        if (!listsMatch(oldTypePar, newTypePar)) {
            int insertHint;
            if (oldTypePar.nonEmpty() && newTypePar.nonEmpty()) {
                insertHint = oldTypePar.head.pos;
            } else {
                insertHint = localPointer;
            }
            copyTo(localPointer, localPointer = insertHint);
            boolean parens = oldTypePar.isEmpty() && newTypePar.nonEmpty();
            localPointer = diffParameterList(oldTypePar, newTypePar,
                    parens ? new JavaTokenId[] { JavaTokenId.LT, JavaTokenId.GT } : null,
                    localPointer, Measure.ARGUMENT);
            if (oldTypePar.nonEmpty()) {
                tokenSequence.move(endPos(oldTypePar.last()));
                moveToSrcRelevant(tokenSequence, Direction.FORWARD);
                moveToSrcRelevant(tokenSequence, Direction.FORWARD);//skips > and any subsequent unimportant tokens
                int end = tokenSequence.offset();
                if (newTypePar.nonEmpty())
                    copyTo(localPointer, end);
                localPointer = end;
            }
        }
        if (nameChanged(oldT.name, newT.name)) {
            printer.print(newT.name);
            diffInfo.put(localPointer, NbBundle.getMessage(CasualDiff.class,"TXT_UpdateReferenceTo",oldT.name));
            localPointer = localPointer + oldT.name.length();
        }
        copyTo(localPointer, bounds[1]);
        return bounds[1];
    }

    protected int diffSelect(JCFieldAccess oldT, JCFieldAccess newT, int[] bounds) {
        return diffSelect(oldT, newT, bounds, null, null);

            diffIdent((JCIdent) oldTident, (JCIdent) newTident, bounds);
        }
    }
    
    protected int diffLambda(JCLambda oldT, JCLambda newT, int[] bounds) {
        int localPointer = bounds[0];
        int posHint;
        if (oldT.params.isEmpty()) {
            // compute the position. Find the parameters closing ')', its
            // start position is important for us. This is used when 
            // there was not any parameter in original tree.
            int startOffset = oldT.pos;

            moveFwdToToken(tokenSequence, startOffset, JavaTokenId.RPAREN);
            posHint = tokenSequence.offset();
        } else {
            // take the position of the first old parameter
            posHint = oldT.params.iterator().next().getStartPosition();
        }
        if (!listsMatch(oldT.params, newT.params)) {
            copyTo(localPointer, posHint);
            int old = printer.setPrec(TreeInfo.noPrec);
            parameterPrint = true;
            Name oldEnclClassName = printer.enclClassName;
            printer.enclClassName = null;
            localPointer = diffParameterList(oldT.params, newT.params, null, posHint, Measure.MEMBER);
            printer.enclClassName = oldEnclClassName;
            parameterPrint = false;
            printer.setPrec(old);
        }
        //make sure the ')' is printed:
        moveFwdToToken(tokenSequence, oldT.params.isEmpty() ? posHint : endPos(oldT.params.last()), JavaTokenId.RPAREN);
        tokenSequence.moveNext();
        posHint = tokenSequence.offset();
        if (localPointer < posHint)
            copyTo(localPointer, localPointer = posHint);
        if (oldT.body != null && newT.body != null) {
            int[] bodyBounds = getBounds(oldT.body);
            copyTo(localPointer, bodyBounds[0]);
            localPointer = diffTree(oldT.body, newT.body, bodyBounds);
        }
        copyTo(localPointer, bounds[1]);
        return bounds[1];
    }

    protected int diffFieldGroup(FieldGroupTree oldT, FieldGroupTree newT, int[] bounds) {
        if (!listsMatch(oldT.getVariables(), newT.getVariables())) {


        // don't use visitor, since we want fast-fail behavior
        switch (t1.getTag()) {
          case TOPLEVEL:
              return ((JCCompilationUnit)t1).sourcefile.equals(((JCCompilationUnit)t2).sourcefile);
          case IMPORT:
              return matchImport((JCImport)t1, (JCImport)t2);
          case CLASSDEF:
              return ((JCClassDecl)t1).sym == ((JCClassDecl)t2).sym;
          case METHODDEF:
              return ((JCMethodDecl)t1).sym == ((JCMethodDecl)t2).sym;
          case VARDEF:
              return ((JCVariableDecl)t1).sym == ((JCVariableDecl)t2).sym;
          case SKIP:
              return true;
          case BLOCK:
              return matchBlock((JCBlock)t1, (JCBlock)t2);
          case DOLOOP:
              return matchDoLoop((JCDoWhileLoop)t1, (JCDoWhileLoop)t2);
          case WHILELOOP:
              return matchWhileLoop((JCWhileLoop)t1, (JCWhileLoop)t2);
          case FORLOOP:
              return matchForLoop((JCForLoop)t1, (JCForLoop)t2);
          case FOREACHLOOP:
              return matchForeachLoop((JCEnhancedForLoop)t1, (JCEnhancedForLoop)t2);
          case LABELLED:
              return matchLabelled((JCLabeledStatement)t1, (JCLabeledStatement)t2);
          case SWITCH:
              return matchSwitch((JCSwitch)t1, (JCSwitch)t2);
          case CASE:
              return matchCase((JCCase)t1, (JCCase)t2);
          case SYNCHRONIZED:
              return matchSynchronized((JCSynchronized)t1, (JCSynchronized)t2);
          case TRY:
              return matchTry((JCTry)t1, (JCTry)t2);
          case CATCH:
              return matchCatch((JCCatch)t1, (JCCatch)t2);
          case CONDEXPR:
              return matchConditional((JCConditional)t1, (JCConditional)t2);
          case IF:
              return matchIf((JCIf)t1, (JCIf)t2);
          case EXEC:
              return treesMatch(((JCExpressionStatement)t1).expr, ((JCExpressionStatement)t2).expr);
          case BREAK:
              return matchBreak((JCBreak)t1, (JCBreak)t2);
          case CONTINUE:
              return matchContinue((JCContinue)t1, (JCContinue)t2);
          case RETURN:
              return treesMatch(((JCReturn)t1).expr, ((JCReturn)t2).expr);
          case THROW:
              return treesMatch(((JCThrow)t1).expr, ((JCThrow)t2).expr);
          case ASSERT:
              return matchAssert((JCAssert)t1, (JCAssert)t2);
          case APPLY:
              return matchApply((JCMethodInvocation)t1, (JCMethodInvocation)t2);
          case NEWCLASS:
              // #97501: workaround. Not sure about comparing symbols and their
              // copying in ImmutableTreeTranslator, making workaround with
              // minimal impact - issue has to be fixed correctly in the future.
              if (((JCNewClass)t2).def != null) ((JCNewClass)t2).def.sym = null;
              return matchNewClass((JCNewClass)t1, (JCNewClass)t2);
          case NEWARRAY:
              return matchNewArray((JCNewArray)t1, (JCNewArray)t2);
          case PARENS:
              return treesMatch(((JCParens)t1).expr, ((JCParens)t2).expr);
          case ASSIGN:
              return matchAssign((JCAssign)t1, (JCAssign)t2);
          case TYPECAST:
              return matchTypeCast((JCTypeCast)t1, (JCTypeCast)t2);
          case TYPETEST:
              return matchTypeTest((JCInstanceOf)t1, (JCInstanceOf)t2);
          case INDEXED:
              return matchIndexed((JCArrayAccess)t1, (JCArrayAccess)t2);
          case SELECT:
              return matchSelect((JCFieldAccess) t1, (JCFieldAccess) t2);
          case IDENT:
              return ((JCIdent)t1).getName().contentEquals(((JCIdent)t2).getName());
          case LITERAL:
              return matchLiteral((JCLiteral)t1, (JCLiteral)t2);
          case TYPEIDENT:
              return ((JCPrimitiveTypeTree)t1).typetag == ((JCPrimitiveTypeTree)t2).typetag;
          case TYPEARRAY:
              return treesMatch(((JCArrayTypeTree)t1).elemtype, ((JCArrayTypeTree)t2).elemtype);
          case TYPEAPPLY:
              return matchTypeApply((JCTypeApply)t1, (JCTypeApply)t2);
          case TYPEPARAMETER:
              return matchTypeParameter((JCTypeParameter)t1, (JCTypeParameter)t2);
          case WILDCARD:
              return matchWildcard((JCWildcard)t1, (JCWildcard)t2);
          case TYPEBOUNDKIND:
              return ((TypeBoundKind)t1).kind == ((TypeBoundKind)t2).kind;
          case ANNOTATION:
              return matchAnnotation((JCAnnotation)t1, (JCAnnotation)t2);
          case LETEXPR:
              return matchLetExpr((LetExpr)t1, (LetExpr)t2);
          case POS:
          case NEG:
          case NOT:
          case COMPL:
          case PREINC:
          case PREDEC:
          case POSTINC:
          case POSTDEC:
          case NULLCHK:
              return matchUnary((JCUnary)t1, (JCUnary)t2);
          case OR:
          case AND:
          case BITOR:
          case BITXOR:
          case BITAND:
          case EQ:
          case NE:
          case LT:
          case GT:
          case LE:
          case GE:
          case SL:
          case SR:
          case USR:
          case PLUS:
          case MINUS:
          case MUL:
          case DIV:
          case MOD:
              return matchBinary((JCBinary)t1, (JCBinary)t2);
          case BITOR_ASG:
          case BITXOR_ASG:
          case BITAND_ASG:
          case SL_ASG:
          case SR_ASG:
          case USR_ASG:
          case PLUS_ASG:
          case MINUS_ASG:
          case MUL_ASG:
          case DIV_ASG:
          case MOD_ASG:
              return matchAssignop((JCAssignOp)t1, (JCAssignOp)t2);
          default:
              String msg = ((com.sun.source.tree.Tree)t1).getKind().toString() +

        }

        switch (oldT.getTag()) {
          case TOPLEVEL:
              diffTopLevel((JCCompilationUnit)oldT, (JCCompilationUnit)newT);
              break;
          case IMPORT:
              retVal = diffImport((JCImport)oldT, (JCImport)newT, elementBounds);
              break;
          case CLASSDEF:
              retVal = diffClassDef((JCClassDecl)oldT, (JCClassDecl)newT, elementBounds);
              break;
          case METHODDEF:
              retVal = diffMethodDef((JCMethodDecl)oldT, (JCMethodDecl)newT, elementBounds);
              break;
          case VARDEF:
              retVal = diffVarDef((JCVariableDecl)oldT, (JCVariableDecl)newT, elementBounds);
              break;
          case SKIP:
              copyTo(elementBounds[0], elementBounds[1]);
              retVal = elementBounds[1];
              break;
          case BLOCK:
              retVal = diffBlock((JCBlock)oldT, (JCBlock)newT, elementBounds);
              break;
          case DOLOOP:
              retVal = diffDoLoop((JCDoWhileLoop)oldT, (JCDoWhileLoop)newT, elementBounds);
              break;
          case WHILELOOP:
              retVal = diffWhileLoop((JCWhileLoop)oldT, (JCWhileLoop)newT, elementBounds);
              break;
          case FORLOOP:
              retVal = diffForLoop((JCForLoop)oldT, (JCForLoop)newT, elementBounds);
              break;
          case FOREACHLOOP:
              retVal = diffForeachLoop((JCEnhancedForLoop)oldT, (JCEnhancedForLoop)newT, elementBounds);
              break;
          case LABELLED:
              retVal = diffLabelled((JCLabeledStatement)oldT, (JCLabeledStatement)newT, elementBounds);
              break;
          case SWITCH:
              retVal = diffSwitch((JCSwitch)oldT, (JCSwitch)newT, elementBounds);
              break;
          case CASE:
              retVal = diffCase((JCCase)oldT, (JCCase)newT, elementBounds);
              break;
          case SYNCHRONIZED:
              retVal = diffSynchronized((JCSynchronized)oldT, (JCSynchronized)newT, elementBounds);
              break;
          case TRY:
              retVal = diffTry((JCTry)oldT, (JCTry)newT, elementBounds);
              break;
          case CATCH:
              retVal = diffCatch((JCCatch)oldT, (JCCatch)newT, elementBounds);
              break;
          case CONDEXPR:
              retVal = diffConditional((JCConditional)oldT, (JCConditional)newT, elementBounds);
              break;
          case IF:
              retVal = diffIf((JCIf)oldT, (JCIf)newT, elementBounds);
              break;
          case EXEC:
              retVal = diffExec((JCExpressionStatement)oldT, (JCExpressionStatement)newT, elementBounds);
              break;
          case BREAK:
              retVal = diffBreak((JCBreak)oldT, (JCBreak)newT, elementBounds);
              break;
          case CONTINUE:
              retVal = diffContinue((JCContinue)oldT, (JCContinue)newT, elementBounds);
              break;
          case RETURN:
              retVal = diffReturn((JCReturn)oldT, (JCReturn)newT, elementBounds);
              break;
          case THROW:
              retVal = diffThrow((JCThrow)oldT, (JCThrow)newT,elementBounds);
              break;
          case ASSERT:
              retVal = diffAssert((JCAssert)oldT, (JCAssert)newT, elementBounds);
              break;
          case APPLY:
              retVal = diffApply((JCMethodInvocation)oldT, (JCMethodInvocation)newT, elementBounds);
              break;
          case NEWCLASS:
              retVal = diffNewClass((JCNewClass)oldT, (JCNewClass)newT, elementBounds);
              break;
          case NEWARRAY:
              retVal = diffNewArray((JCNewArray)oldT, (JCNewArray)newT, elementBounds);
              break;
          case PARENS:
              retVal = diffParens((JCParens)oldT, (JCParens)newT, elementBounds);
              break;
          case ASSIGN:
              retVal = diffAssign((JCAssign)oldT, (JCAssign)newT, parent, elementBounds);
              break;
          case TYPECAST:
              retVal = diffTypeCast((JCTypeCast)oldT, (JCTypeCast)newT, elementBounds);
              break;
          case TYPETEST:
              retVal = diffTypeTest((JCInstanceOf)oldT, (JCInstanceOf)newT, elementBounds);
              break;
          case INDEXED:
              retVal = diffIndexed((JCArrayAccess)oldT, (JCArrayAccess)newT, elementBounds);
              break;
          case SELECT:
              retVal = diffSelect((JCFieldAccess)oldT, (JCFieldAccess)newT, elementBounds);
              break;
          case IDENT:
              retVal = diffIdent((JCIdent)oldT, (JCIdent)newT, elementBounds);
              break;
          case LITERAL:
              retVal = diffLiteral((JCLiteral)oldT, (JCLiteral)newT, elementBounds);
              break;
          case TYPEIDENT:
              retVal = diffTypeIdent((JCPrimitiveTypeTree)oldT, (JCPrimitiveTypeTree)newT, elementBounds);
              break;
          case TYPEARRAY:
              retVal = diffTypeArray((JCArrayTypeTree)oldT, (JCArrayTypeTree)newT, elementBounds);
              break;
          case TYPEAPPLY:
              retVal = diffTypeApply((JCTypeApply)oldT, (JCTypeApply)newT, elementBounds);
              break;
          case TYPEPARAMETER:
              retVal = diffTypeParameter((JCTypeParameter)oldT, (JCTypeParameter)newT, elementBounds);
              break;
          case WILDCARD:
              retVal = diffWildcard((JCWildcard)oldT, (JCWildcard)newT, elementBounds);
              break;
          case TYPEBOUNDKIND:
              retVal = diffTypeBoundKind((TypeBoundKind)oldT, (TypeBoundKind)newT, elementBounds);
              break;
          case ANNOTATION:
              retVal = diffAnnotation((JCAnnotation)oldT, (JCAnnotation)newT, elementBounds);
              break;
          case LETEXPR:
              diffLetExpr((LetExpr)oldT, (LetExpr)newT);
              break;
          case POS:
          case NEG:
          case NOT:
          case COMPL:
          case PREINC:
          case PREDEC:
          case POSTINC:
          case POSTDEC:
          case NULLCHK:
              retVal = diffUnary((JCUnary)oldT, (JCUnary)newT, elementBounds);
              break;
          case OR:
          case AND:
          case BITOR:
          case BITXOR:
          case BITAND:
          case EQ:
          case NE:
          case LT:
          case GT:
          case LE:
          case GE:
          case SL:
          case SR:
          case USR:
          case PLUS:
          case MINUS:
          case MUL:
          case DIV:
          case MOD:
              retVal = diffBinary((JCBinary)oldT, (JCBinary)newT, elementBounds);
              break;
          case BITOR_ASG:
          case BITXOR_ASG:
          case BITAND_ASG:
          case SL_ASG:
          case SR_ASG:
          case USR_ASG:
          case PLUS_ASG:
          case MINUS_ASG:
          case MUL_ASG:
          case DIV_ASG:
          case MOD_ASG:
              retVal = diffAssignop((JCAssignOp)oldT, (JCAssignOp)newT, elementBounds);
              break;
          case ERRONEOUS:
              diffErroneous((JCErroneous)oldT, (JCErroneous)newT, elementBounds);
              break;
          case MODIFIERS:
              retVal = diffModifiers((JCModifiers) oldT, (JCModifiers) newT, parent, elementBounds[0]);
              copyTo(retVal, elementBounds[1]);
              break;
          case TYPEUNION:
              retVal = diffUnionType((JCTypeUnion) oldT, (JCTypeUnion) newT, elementBounds);
              break;
          case LAMBDA:
              retVal = diffLambda((JCLambda) oldT, (JCLambda) newT, elementBounds);
              break;
          case REFERENCE:
              retVal = diffMemberReference((JCMemberReference) oldT, (JCMemberReference) newT, elementBounds);
              break;
          default:
              // handle special cases like field groups and enum constants
              if (oldT.getKind() == Kind.OTHER) {

Lines 512-517 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/save/ElementOverlay.java (+20 lines)
512	}	512	}
513		513
514	@Override	514	@Override
		515	public <A extends Annotation> A[] getAnnotations(Class<A> annotationType) {
		516	throw new UnsupportedOperationException("Not supported yet.");
		517	}
		518
		519	@Override
515	public Set<Modifier> getModifiers() {	520	public Set<Modifier> getModifiers() {
516	return mods;	521	return mods;
517	}	522	}
Lines 596-601 Link Here
596	}	601	}
597		602
598	@Override	603	@Override
		604	public <A extends Annotation> A[] getAnnotations(Class<A> annotationType) {
		605	throw new UnsupportedOperationException("Not supported yet.");
		606	}
		607
		608	@Override
599	public Set<Modifier> getModifiers() {	609	public Set<Modifier> getModifiers() {
600	return delegateTo.getModifiers();	610	return delegateTo.getModifiers();
601	}	611	}
Lines 664-669 Link Here
664	}	674	}
665		675
666	@Override	676	@Override
		677	public <A extends Annotation> A[] getAnnotations(Class<A> annotationType) {
		678	throw new UnsupportedOperationException("Not supported yet.");
		679	}
		680
		681	@Override
667	public Set<Modifier> getModifiers() {	682	public Set<Modifier> getModifiers() {
668	throw new UnsupportedOperationException("Not supported yet.");	683	throw new UnsupportedOperationException("Not supported yet.");
669	}	684	}
Lines 734-739 Link Here
734	}	749	}
735		750
736	@Override	751	@Override
		752	public <A extends Annotation> A[] getAnnotations(Class<A> annotationType) {
		753	throw new UnsupportedOperationException("Not supported yet.");
		754	}
		755
		756	@Override
737	public Set<Modifier> getModifiers() {	757	public Set<Modifier> getModifiers() {
738	throw new UnsupportedOperationException("Not supported yet.");	758	throw new UnsupportedOperationException("Not supported yet.");
739	}	759	}

Lines 966-973 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/save/Reformatter.java (-2 / +4 lines)
966	} else {	966	} else {
967	if (!insideForOrCatch)	967	if (!insideForOrCatch)
968	continuationIndent = true;	968	continuationIndent = true;
969	if (scan(node.getType(), p)) {	969	if (node.getType() == null \|\| scan(node.getType(), p)) {
970	spaces(1, fieldGroup);	970	if (node.getType() != null) {
		971	spaces(1, fieldGroup);
		972	}
971	if (!ERROR.contentEquals(node.getName()))	973	if (!ERROR.contentEquals(node.getName()))
972	accept(IDENTIFIER);	974	accept(IDENTIFIER);
973	}	975	}

Lines 118-123 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/tasklist/CompilerSettings.java (+1 lines)
118	if (get(p, ENABLE_LINT_RAWTYPES))	118	if (get(p, ENABLE_LINT_RAWTYPES))
119	sb.append("-Xlint:rawtypes ");	119	sb.append("-Xlint:rawtypes ");
120		120
		121	sb.append("-XDidentifyLambdaCandidate=true ");
121	sb.append("-XDfindDiamond ");	122	sb.append("-XDfindDiamond ");
122		123
123	if (sb.length() > 0 && sb.charAt(sb.length() - 1) == ' ') {	124	if (sb.length() > 0 && sb.charAt(sb.length() - 1) == ' ') {

Lines 105-111 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/transform/FieldGroupTree.java (-2 / +2 lines)
105	return vars.hashCode();	105	return vars.hashCode();
106	}	106	}
107		107
108	public int getTag() {	108	public Tag getTag() {
109	return 0;	109	return Tag.NO_TAG;
110	}	110	}
111	}	111	}

Lines 386-391 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/transform/ImmutableTreeTranslator.java (-1 / +73 lines)
386	public Tree visitLabeledStatement(LabeledStatementTree tree, Object p) {	386	public Tree visitLabeledStatement(LabeledStatementTree tree, Object p) {
387	return rewriteChildren(tree);	387	return rewriteChildren(tree);
388	}	388	}
		389	public Tree visitLambdaExpression(LambdaExpressionTree tree, Object p) {
		390	return rewriteChildren(tree);
		391	}
389	public Tree visitSwitch(SwitchTree tree, Object p) {	392	public Tree visitSwitch(SwitchTree tree, Object p) {
390	return rewriteChildren(tree);	393	return rewriteChildren(tree);
391	}	394	}
Lines 455-463 Link Here
455	public Tree visitInstanceOf(InstanceOfTree tree, Object p) {	458	public Tree visitInstanceOf(InstanceOfTree tree, Object p) {
456	return rewriteChildren(tree);	459	return rewriteChildren(tree);
457	}	460	}
		461	public Tree visitIntersectionType(IntersectionTypeTree tree, Object p) {
		462	return rewriteChildren(tree);
		463	}
458	public Tree visitArrayAccess(ArrayAccessTree tree, Object p) {	464	public Tree visitArrayAccess(ArrayAccessTree tree, Object p) {
459	return rewriteChildren(tree);	465	return rewriteChildren(tree);
460	}	466	}
		467	@Override
		468	public Tree visitMemberReference(MemberReferenceTree tree, Object p) {
		469	return rewriteChildren(tree);
		470	}
461	public Tree visitMemberSelect(MemberSelectTree tree, Object p) {	471	public Tree visitMemberSelect(MemberSelectTree tree, Object p) {
462	if (tree instanceof QualIdentTree) {	472	if (tree instanceof QualIdentTree) {
463	QualIdentTree qit = (QualIdentTree) tree;	473	QualIdentTree qit = (QualIdentTree) tree;
Lines 497-502 Link Here
497	public Tree visitWildcard(WildcardTree tree, Object p) {	507	public Tree visitWildcard(WildcardTree tree, Object p) {
498	return rewriteChildren(tree);	508	return rewriteChildren(tree);
499	}	509	}
		510	public Tree visitAnnotatedType(AnnotatedTypeTree tree, Object p) {
		511	return rewriteChildren(tree);
		512	}
500	public Tree visitAnnotation(AnnotationTree tree, Object p) {	513	public Tree visitAnnotation(AnnotationTree tree, Object p) {
501	return rewriteChildren(tree);	514	return rewriteChildren(tree);
502	}	515	}
Lines 737-742 Link Here
737	return tree;	750	return tree;
738	}	751	}
739		752
		753	protected final LambdaExpressionTree rewriteChildren(LambdaExpressionTree tree) {
		754	Tree body = translate(tree.getBody());
		755	List<? extends VariableTree> parameters = translate(tree.getParameters());
		756
		757	if (body != tree.getBody() \|\|
		758	parameters != tree.getParameters())
		759	{
		760	LambdaExpressionTree n = make.LambdaExpression(parameters, body);
		761	model.setType(n, model.getType(tree));
		762	copyCommentTo(tree,n);
		763	copyPosTo(tree,n);
		764	tree = n;
		765	}
		766	return tree;
		767	}
		768
740	protected final SwitchTree rewriteChildren(SwitchTree tree) {	769	protected final SwitchTree rewriteChildren(SwitchTree tree) {
741	ExpressionTree selector = (ExpressionTree)translate(tree.getExpression());	770	ExpressionTree selector = (ExpressionTree)translate(tree.getExpression());
742	List<? extends CaseTree> cases = translateStable(tree.getCases());	771	List<? extends CaseTree> cases = translateStable(tree.getCases());
Lines 1059-1064 Link Here
1059	return tree;	1088	return tree;
1060	}	1089	}
1061		1090
		1091	protected final IntersectionTypeTree rewriteChildren(IntersectionTypeTree tree) {
		1092	List<? extends Tree> bounds = translate(tree.getBounds());
		1093	if (!safeEquals(bounds, tree.getBounds())) {
		1094	IntersectionTypeTree n = make.IntersectionType(bounds);
		1095	model.setType(n, model.getType(tree));
		1096	copyCommentTo(tree,n);
		1097	copyPosTo(tree,n);
		1098	tree = n;
		1099	}
		1100	return tree;
		1101	}
		1102
1062	protected final ArrayAccessTree rewriteChildren(ArrayAccessTree tree) {	1103	protected final ArrayAccessTree rewriteChildren(ArrayAccessTree tree) {
1063	ExpressionTree array = (ExpressionTree)translate(tree.getExpression());	1104	ExpressionTree array = (ExpressionTree)translate(tree.getExpression());
1064	ExpressionTree index = (ExpressionTree)translate(tree.getIndex());	1105	ExpressionTree index = (ExpressionTree)translate(tree.getIndex());
Lines 1157-1169 Link Here
1157	return tree;	1198	return tree;
1158	}	1199	}
1159		1200
		1201	protected final AnnotatedTypeTree rewriteChildren(AnnotatedTypeTree tree) {
		1202	List<? extends AnnotationTree> annotations = translate(tree.getAnnotations());
		1203	ExpressionTree underlyingType = (ExpressionTree)translate(tree.getUnderlyingType());
		1204	if (!annotations.equals(tree.getAnnotations()) \|\| underlyingType != tree.getUnderlyingType()) {
		1205	AnnotatedTypeTree n = make.AnnotatedType(annotations, underlyingType);
		1206	model.setType(n, model.getType(tree));
		1207	copyCommentTo(tree,n);
		1208	copyPosTo(tree,n);
		1209	tree = n;
		1210	}
		1211	return tree;
		1212	}
		1213
1160	protected final AnnotationTree rewriteChildren(AnnotationTree tree) {	1214	protected final AnnotationTree rewriteChildren(AnnotationTree tree) {
1161	Tree annotationType = translate(tree.getAnnotationType());	1215	Tree annotationType = translate(tree.getAnnotationType());
1162	List<? extends ExpressionTree> args = translate(tree.getArguments());	1216	List<? extends ExpressionTree> args = translate(tree.getArguments());
1163	if (annotationType!=tree.getAnnotationType() \|\| !args.equals(tree.getArguments())) {	1217	if (annotationType!=tree.getAnnotationType() \|\| !args.equals(tree.getArguments())) {
1164	if (args != tree.getArguments())	1218	if (args != tree.getArguments())
1165	args = optimize(args);	1219	args = optimize(args);
1166	AnnotationTree n = make.Annotation(annotationType, args);	1220	AnnotationTree n = tree.getKind() == Kind.ANNOTATION
		1221	? make.Annotation(annotationType, args)
		1222	: make.TypeAnnotation(annotationType, args);
1167	model.setType(n, model.getType(tree));	1223	model.setType(n, model.getType(tree));
1168	copyCommentTo(tree,n);	1224	copyCommentTo(tree,n);
1169	tree = n;	1225	tree = n;
Lines 1200-1204 Link Here
1200	return tree;	1256	return tree;
1201	}	1257	}
1202		1258
		1259	private Tree rewriteChildren(MemberReferenceTree node) {
		1260	ExpressionTree qualifierExpression = (ExpressionTree) translate(node.getQualifierExpression());
		1261	List<ExpressionTree> typeArguments = (List<ExpressionTree>) translate(node.getTypeArguments());
		1262
		1263	if (qualifierExpression != node.getQualifierExpression() \|\|
		1264	typeArguments != node.getTypeArguments())
		1265	{
		1266	MemberReferenceTree n = make.MemberReference(node.getMode(), node.getName(), qualifierExpression, typeArguments);
		1267	model.setType(n, model.getType(node));
		1268	copyCommentTo(node,n);
		1269	copyPosTo(node,n);
		1270	node = n;
		1271	}
		1272	return node;
		1273	}
		1274
1203		1275
1204	}	1276	}

Lines 121-127 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/usages/BinaryAnalyser.java (-1 / +1 lines)
121		121
122		122
123		123
124	/**	124	/**TODO: the full index does not handle invokeDynamicInfo, MethodHandleInfo and MethodTypeInfo.
125	*	125	*
126	* @author Petr Hrebejk, Tomas Zezula	126	* @author Petr Hrebejk, Tomas Zezula
127	*/	127	*/




import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ErrorType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVariable;

		break;
	    case DECLARED:
            {
                sb.append('L');	    // NOI18N
                TypeElement te = (TypeElement) ((DeclaredType)type).asElement();
                encodeClassName(te, sb,'/');
                sb.append(';');	    // NOI18N
                break;
            }
	    case TYPEVAR:
            {

                    break;
                }                
            }
            case INTERSECTION:
            {
                encodeType(((IntersectionType) type).getBounds().get(0), sb);
                break;
            }
	    default:
		throw new IllegalArgumentException ();
	}                

Lines 44-58 Link Here

(-)a/java.source/test/unit/src/org/netbeans/api/java/source/gen/AddCastTest.java (-171 / +461 lines)
44	package org.netbeans.api.java.source.gen;	44	package org.netbeans.api.java.source.gen;
45		45
46	import com.sun.source.tree.BlockTree;	46	import com.sun.source.tree.BlockTree;
47	import com.sun.source.tree.ClassTree;
48	import com.sun.source.tree.CompilationUnitTree;	47	import com.sun.source.tree.CompilationUnitTree;
49	import com.sun.source.tree.ExpressionTree;	48	import com.sun.source.tree.ExpressionTree;
50	import com.sun.source.tree.ForLoopTree;	49	import com.sun.source.tree.LambdaExpressionTree;
51	import com.sun.source.tree.MethodTree;	50	import com.sun.source.tree.LiteralTree;
		51	import com.sun.source.tree.MemberReferenceTree;
		52	import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
		53	import com.sun.source.tree.ReturnTree;
52	import com.sun.source.tree.VariableTree;	54	import com.sun.source.tree.VariableTree;
		55	import com.sun.source.util.TreeScanner;
53	import java.io.File;	56	import java.io.File;
54	import java.io.IOException;	57	import java.io.IOException;
55	import javax.lang.model.type.TypeKind;	58	import java.util.Collections;
		59	import java.util.EnumSet;
		60	import javax.lang.model.element.Modifier;
56	import org.netbeans.api.java.source.Task;	61	import org.netbeans.api.java.source.Task;
57	import org.netbeans.api.java.source.JavaSource;	62	import org.netbeans.api.java.source.JavaSource;
58	import org.netbeans.api.java.source.JavaSource.Phase;	63	import org.netbeans.api.java.source.JavaSource.Phase;
Lines 66-121 Link Here
66	*	71	*
67	* @author Pavel Flaska	72	* @author Pavel Flaska
68	*/	73	*/
69	public class AddCastTest extends GeneratorTestMDRCompat {	74	public class LambdaTest extends GeneratorTestMDRCompat {
70		75
71	/** Creates a new instance of AddCastTest */	76	/** Creates a new instance of AddCastTest */
72	public AddCastTest(String name) {	77	public LambdaTest(String name) {
73	super(name);	78	super(name);
74	}	79	}
75		80
76	public static NbTestSuite suite() {	81	public static NbTestSuite suite() {
77	NbTestSuite suite = new NbTestSuite();	82	NbTestSuite suite = new NbTestSuite();
78	suite.addTestSuite(AddCastTest.class);	83	suite.addTestSuite(LambdaTest.class);
79	return suite;	84	return suite;
80	}	85	}
81		86
82	public void testAddCastToDeclStmt() throws Exception {	87	public void testPrintMemberReference() throws Exception {
83	testFile = new File(getWorkDir(), "Test.java");	88	testFile = new File(getWorkDir(), "Test.java");
84	TestUtilities.copyStringToFile(testFile,	89	TestUtilities.copyStringToFile(testFile,
85	"package hierbas.del.litoral;\n\n" +	90	"package hierbas.del.litoral;\n\n" +
86	"import java.util.*;\n\n" +	91	"public class Test {\n" +
87	"public class Test<E> {\n" +	92	" public static void taragui() {\n" +
88	" public void taragui() {\n" +	93	" Runnable r = null;\n" +
89	" System.err.println(\"taragui() method\");\n" +
90	" String s = \"Oven.\";\n" +
91	"// line comment\n" +
92	" }\n" +	94	" }\n" +
93	"}\n"	95	"}\n"
94	);	96	);
95	String golden =	97	String golden =
96	"package hierbas.del.litoral;\n\n" +	98	"package hierbas.del.litoral;\n\n" +
97	"import java.util.*;\n\n" +	99	"public class Test {\n" +
98	"public class Test<E> {\n" +	100	" public static void taragui() {\n" +
99	" public void taragui() {\n" +	101	" Runnable r = Test::taragui;\n" +
100	" System.err.println(\"taragui() method\");\n" +
101	" String s = (String) \"Oven.\";\n" +
102	"// line comment\n" +
103	" }\n" +	102	" }\n" +
104	"}\n";	103	"}\n";
105	JavaSource src = getJavaSource(testFile);	104	JavaSource src = getJavaSource(testFile);
106		105
107	Task<WorkingCopy> task = new Task<WorkingCopy>() {	106	Task<WorkingCopy> task = new Task<WorkingCopy>() {
108		107
109	public void run(WorkingCopy workingCopy) throws IOException {	108	public void run(final WorkingCopy workingCopy) throws IOException {
110	workingCopy.toPhase(Phase.RESOLVED);	109	workingCopy.toPhase(Phase.RESOLVED);
111	CompilationUnitTree cut = workingCopy.getCompilationUnit();	110	CompilationUnitTree cut = workingCopy.getCompilationUnit();
112	TreeMaker make = workingCopy.getTreeMaker();	111	final TreeMaker make = workingCopy.getTreeMaker();
113	ClassTree clazz = (ClassTree) cut.getTypeDecls().get(0);	112	new TreeScanner<Void, Void>() {
114	MethodTree method = (MethodTree) clazz.getMembers().get(1);	113	@Override public Void visitLiteral(LiteralTree node, Void p) {
115	VariableTree var = (VariableTree) method.getBody().getStatements().get(1);	114	workingCopy.rewrite(node, make.MemberReference(ReferenceMode.INVOKE, make.Identifier("Test"), "taragui", Collections.<ExpressionTree>emptyList()));
116	ExpressionTree init = var.getInitializer();	115	return super.visitLiteral(node, p);
117	ExpressionTree cast = make.TypeCast(make.Identifier("String"), init);	116	}
118	workingCopy.rewrite(init, cast);	117	}.scan(workingCopy.getCompilationUnit(), null);
119	}	118	}
120		119
121	};	120	};
Lines 125-171 Link Here
125	assertEquals(golden, res);	124	assertEquals(golden, res);
126	}	125	}
127		126
128	public void testAddCastInForWithoutSteps() throws Exception {	127	public void testBasicLambdaDiff() throws Exception {
129	testFile = new File(getWorkDir(), "Test.java");	128	testFile = new File(getWorkDir(), "Test.java");
130	TestUtilities.copyStringToFile(testFile,	129	TestUtilities.copyStringToFile(testFile,
131	"package hierbas.del.litoral;\n\n" +	130	"package hierbas.del.litoral;\n\n" +
132	"import java.util.*;\n\n" +	131	"public class Test {\n" +
133	"public class Test<E> {\n" +	132	" public static void taragui() {\n" +
134	" public void cast() {\n" +	133	" ChangeListener l = (e) -> {};\n" +
135	" Object o = null;\n" +
136	" for (int i = 0; i < 5; ) {\n" +
137	" String s = o;\n" +
138	" }\n" +
139	" }\n" +	134	" }\n" +
140	"}\n"	135	"}\n"
141	);	136	);
142	String golden =	137	String golden =
143	"package hierbas.del.litoral;\n\n" +	138	"package hierbas.del.litoral;\n\n" +
144	"import java.util.*;\n\n" +	139	"public class Test {\n" +
145	"public class Test<E> {\n" +	140	" public static void taragui() {\n" +
146	" public void cast() {\n" +	141	" ChangeListener l = (f) -> {};\n" +
147	" Object o = null;\n" +
148	" for (int i = 0; i < 5; ) {\n" +
149	" String s = (String) o;\n" +
150	" }\n" +
151	" }\n" +	142	" }\n" +
152	"}\n";	143	"}\n";
153	JavaSource src = getJavaSource(testFile);	144	JavaSource src = getJavaSource(testFile);
154		145
155	Task<WorkingCopy> task = new Task<WorkingCopy>() {	146	Task<WorkingCopy> task = new Task<WorkingCopy>() {
156		147
157	public void run(WorkingCopy workingCopy) throws IOException {	148	public void run(final WorkingCopy workingCopy) throws IOException {
158	workingCopy.toPhase(Phase.RESOLVED);	149	workingCopy.toPhase(Phase.RESOLVED);
159	CompilationUnitTree cut = workingCopy.getCompilationUnit();	150	CompilationUnitTree cut = workingCopy.getCompilationUnit();
160	TreeMaker make = workingCopy.getTreeMaker();	151	final TreeMaker make = workingCopy.getTreeMaker();
161	ClassTree clazz = (ClassTree) cut.getTypeDecls().get(0);	152	new TreeScanner<Void, Void>() {
162	MethodTree method = (MethodTree) clazz.getMembers().get(1);	153	@Override public Void visitVariable(VariableTree node, Void p) {
163	ForLoopTree forLoop = (ForLoopTree) method.getBody().getStatements().get(1);	154	if (node.getName().contentEquals("e")) {
164	BlockTree block = (BlockTree) forLoop.getStatement();	155	workingCopy.rewrite(node, make.setLabel(node, "f"));
165	VariableTree vt = (VariableTree) block.getStatements().get(0);	156	}
166	ExpressionTree init = vt.getInitializer();	157	return super.visitVariable(node, p);
167	ExpressionTree cast = make.TypeCast(make.Identifier("String"), init);	158	}
168	workingCopy.rewrite(init, cast);	159	}.scan(workingCopy.getCompilationUnit(), null);
169	}	160	}
170		161
171	};	162	};
Lines 175-230 Link Here
175	assertEquals(golden, res);	166	assertEquals(golden, res);
176	}	167	}
177		168
178	/*	169	public void testAddFirstLambdaParam() throws Exception {
179	* #94324
180	*/
181	public void testAddCast94324() throws Exception {
182	testFile = new File(getWorkDir(), "Test.java");	170	testFile = new File(getWorkDir(), "Test.java");
183	TestUtilities.copyStringToFile(testFile,	171	TestUtilities.copyStringToFile(testFile,
184	"package javaapplication3;\n" +	172	"package hierbas.del.litoral;\n\n" +
185	"\n" +	173	"public class Test {\n" +
186	"public class Klasa {\n" +	174	" public static void taragui() {\n" +
187	" \n" +	175	" ChangeListener l = () -> {};\n" +
188	" static Object method() {\n" +
189	" return null;\n" +
190	" }\n" +	176	" }\n" +
191	" \n" +	177	"}\n"
192	" public static void main(String[] args) {\n" +	178	);
193	" // TODO code application logic here\n" +	179	String golden =
194	" String s = Klasa.method();\n" +	180	"package hierbas.del.litoral;\n\n" +
		181	"public class Test {\n" +
		182	" public static void taragui() {\n" +
		183	" ChangeListener l = (e) -> {};\n" +
195	" }\n" +	184	" }\n" +
196	"\n" +
197	"}\n"
198	);
199	String golden =
200	"package javaapplication3;\n" +
201	"\n" +
202	"public class Klasa {\n" +
203	" \n" +
204	" static Object method() {\n" +
205	" return null;\n" +
206	" }\n" +
207	" \n" +
208	" public static void main(String[] args) {\n" +
209	" // TODO code application logic here\n" +
210	" String s = (String) Klasa.method();\n" +
211	" }\n" +
212	"\n" +
213	"}\n";	185	"}\n";
214	JavaSource src = getJavaSource(testFile);	186	JavaSource src = getJavaSource(testFile);
215		187
216	Task<WorkingCopy> task = new Task<WorkingCopy>() {	188	Task<WorkingCopy> task = new Task<WorkingCopy>() {
217		189
218	public void run(WorkingCopy workingCopy) throws IOException {	190	public void run(final WorkingCopy workingCopy) throws IOException {
219	workingCopy.toPhase(Phase.RESOLVED);	191	workingCopy.toPhase(Phase.RESOLVED);
220	CompilationUnitTree cut = workingCopy.getCompilationUnit();	192	final TreeMaker make = workingCopy.getTreeMaker();
221	TreeMaker make = workingCopy.getTreeMaker();	193	new TreeScanner<Void, Void>() {
222	ClassTree clazz = (ClassTree) cut.getTypeDecls().get(0);	194	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
223	MethodTree method = (MethodTree) clazz.getMembers().get(2);	195	workingCopy.rewrite(node, make.addLambdaParameter(node, make.Variable(make.Modifiers(EnumSet.noneOf(Modifier.class)), "e", null, null)));
224	VariableTree var = (VariableTree) method.getBody().getStatements().get(0);	196	return super.visitLambdaExpression(node, p);
225	ExpressionTree init = var.getInitializer();	197	}
226	ExpressionTree cast = make.TypeCast(make.Identifier("String"), init);	198	}.scan(workingCopy.getCompilationUnit(), null);
227	workingCopy.rewrite(init, cast);
228	}	199	}
229		200
230	};	201	};
Lines 234-274 Link Here
234	assertEquals(golden, res);	205	assertEquals(golden, res);
235	}	206	}
236		207
237	public void testAddCastLiteral() throws Exception {	208	public void testAddSecondLambdaParam() throws Exception {
238	testFile = new File(getWorkDir(), "Test.java");	209	testFile = new File(getWorkDir(), "Test.java");
239	TestUtilities.copyStringToFile(testFile,	210	TestUtilities.copyStringToFile(testFile,
240	"package javaapplication3;\n" +	211	"package hierbas.del.litoral;\n\n" +
241	"\n" +	212	"public class Test {\n" +
242	"public class Klasa {\n" +	213	" public static void taragui() {\n" +
243	" public static void main(String[] args) {\n" +	214	" ChangeListener l = (e) -> {};\n" +
244	" int i = args.length & 0xFEFE;\n" +
245	" }\n" +	215	" }\n" +
246	"\n" +
247	"}\n"	216	"}\n"
248	);	217	);
249	String golden =	218	String golden =
250	"package javaapplication3;\n" +	219	"package hierbas.del.litoral;\n\n" +
251	"\n" +	220	"public class Test {\n" +
252	"public class Klasa {\n" +	221	" public static void taragui() {\n" +
253	" public static void main(String[] args) {\n" +	222	" ChangeListener l = (e, f) -> {};\n" +
254	" int i = (int) (args.length & 0xFEFE);\n" +
255	" }\n" +	223	" }\n" +
256	"\n" +
257	"}\n";	224	"}\n";
258	JavaSource src = getJavaSource(testFile);	225	JavaSource src = getJavaSource(testFile);
259		226
260	Task<WorkingCopy> task = new Task<WorkingCopy>() {	227	Task<WorkingCopy> task = new Task<WorkingCopy>() {
261		228
262	public void run(WorkingCopy workingCopy) throws IOException {	229	public void run(final WorkingCopy workingCopy) throws IOException {
263	workingCopy.toPhase(Phase.RESOLVED);	230	workingCopy.toPhase(Phase.RESOLVED);
264	CompilationUnitTree cut = workingCopy.getCompilationUnit();	231	final TreeMaker make = workingCopy.getTreeMaker();
265	TreeMaker make = workingCopy.getTreeMaker();	232	new TreeScanner<Void, Void>() {
266	ClassTree clazz = (ClassTree) cut.getTypeDecls().get(0);	233	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
267	MethodTree method = (MethodTree) clazz.getMembers().get(1);	234	workingCopy.rewrite(node, make.addLambdaParameter(node, make.Variable(make.Modifiers(EnumSet.noneOf(Modifier.class)), "f", null, null)));
268	VariableTree var = (VariableTree) method.getBody().getStatements().get(0);	235	return super.visitLambdaExpression(node, p);
269	ExpressionTree init = var.getInitializer();	236	}
270	ExpressionTree cast = make.TypeCast(make.PrimitiveType(TypeKind.INT), make.Parenthesized(init));	237	}.scan(workingCopy.getCompilationUnit(), null);
271	workingCopy.rewrite(init, cast);
272	}	238	}
273		239
274	};	240	};
Lines 277-351 Link Here
277	System.err.println(res);	243	System.err.println(res);
278	assertEquals(golden, res);	244	assertEquals(golden, res);
279	}	245	}
280		246
281	/*	247	public void testPrependSecondLambdaParam() throws Exception {
282	* #94324 - second test. If the moved expression is changed, it is again
283	* rewritten by VeryPretty - in this time, i do not see any solution for
284	* that.
285	//
286	public void testAddCast94324_2() throws Exception {
287	testFile = new File(getWorkDir(), "Test.java");	248	testFile = new File(getWorkDir(), "Test.java");
288	TestUtilities.copyStringToFile(testFile,	249	TestUtilities.copyStringToFile(testFile,
289	"package javaapplication3;\n" +	250	"package hierbas.del.litoral;\n\n" +
290	"\n" +	251	"public class Test {\n" +
291	"public class Klasa {\n" +	252	" public static void taragui() {\n" +
292	" \n" +	253	" ChangeListener l = (e) -> {};\n" +
293	" static Object method() {\n" +
294	" return null;\n" +
295	" }\n" +	254	" }\n" +
296	" \n" +	255	"}\n"
297	" public static void main(String[] args) {\n" +	256	);
298	" // TODO code application logic here\n" +	257	String golden =
299	" String s = Klasa.method();\n" +	258	"package hierbas.del.litoral;\n\n" +
		259	"public class Test {\n" +
		260	" public static void taragui() {\n" +
		261	" ChangeListener l = (f, e) -> {};\n" +
300	" }\n" +	262	" }\n" +
301	"\n" +
302	"}\n"
303	);
304	String golden =
305	"package javaapplication3;\n" +
306	"\n" +
307	"public class Klasa {\n" +
308	" \n" +
309	" static Object method() {\n" +
310	" return null;\n" +
311	" }\n" +
312	" \n" +
313	" public static void main(String[] args) {\n" +
314	" // TODO code application logic here\n" +
315	" String s = (String) javaapplication3.Klasa.metoda();\n" +
316	" }\n" +
317	"\n" +
318	"}\n";	263	"}\n";
319	JavaSource src = getJavaSource(testFile);	264	JavaSource src = getJavaSource(testFile);
320		265
321	CancellableTask<WorkingCopy> task = new CancellableTask<WorkingCopy>() {	266	Task<WorkingCopy> task = new Task<WorkingCopy>() {
322		267
323	public void run(WorkingCopy workingCopy) throws IOException {	268	public void run(final WorkingCopy workingCopy) throws IOException {
324	workingCopy.toPhase(Phase.RESOLVED);	269	workingCopy.toPhase(Phase.RESOLVED);
325	CompilationUnitTree cut = workingCopy.getCompilationUnit();	270	final TreeMaker make = workingCopy.getTreeMaker();
326	TreeMaker make = workingCopy.getTreeMaker();	271	new TreeScanner<Void, Void>() {
327	ClassTree clazz = (ClassTree) cut.getTypeDecls().get(0);	272	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
328	MethodTree method = (MethodTree) clazz.getMembers().get(2);	273	workingCopy.rewrite(node, make.insertLambdaParameter(node, 0, make.Variable(make.Modifiers(EnumSet.noneOf(Modifier.class)), "f", null, null)));
329	VariableTree var = (VariableTree) method.getBody().getStatements().get(0);	274	return super.visitLambdaExpression(node, p);
330	MethodInvocationTree init = (MethodInvocationTree) var.getInitializer();	275	}
331	MethodInvocationTree initCopy = make.MethodInvocation(	276	}.scan(workingCopy.getCompilationUnit(), null);
332	(List<ExpressionTree>) init.getTypeArguments(),
333	make.setLabel((MemberSelectTree) init.getMethodSelect(), "metoda"),
334	init.getArguments()
335	);
336	workingCopy.rewrite(init, initCopy);
337	ExpressionTree cast = make.TypeCast(make.Identifier("String"), initCopy);
338	workingCopy.rewrite(init, cast);
339	}	277	}
340		278
341	public void cancel() {
342	}
343	};	279	};
344	src.runModificationTask(task).commit();	280	src.runModificationTask(task).commit();
345	String res = TestUtilities.copyFileToString(testFile);	281	String res = TestUtilities.copyFileToString(testFile);
346	System.err.println(res);	282	System.err.println(res);
347	assertEquals(golden, res);	283	assertEquals(golden, res);
348	}*/	284	}
		285
		286	public void testRemoveFirstLambdaParam() throws Exception {
		287	testFile = new File(getWorkDir(), "Test.java");
		288	TestUtilities.copyStringToFile(testFile,
		289	"package hierbas.del.litoral;\n\n" +
		290	"public class Test {\n" +
		291	" public static void taragui() {\n" +
		292	" ChangeListener l = (e, f) -> {};\n" +
		293	" }\n" +
		294	"}\n"
		295	);
		296	String golden =
		297	"package hierbas.del.litoral;\n\n" +
		298	"public class Test {\n" +
		299	" public static void taragui() {\n" +
		300	" ChangeListener l = (f) -> {};\n" +
		301	" }\n" +
		302	"}\n";
		303	JavaSource src = getJavaSource(testFile);
		304
		305	Task<WorkingCopy> task = new Task<WorkingCopy>() {
		306
		307	public void run(final WorkingCopy workingCopy) throws IOException {
		308	workingCopy.toPhase(Phase.RESOLVED);
		309	final TreeMaker make = workingCopy.getTreeMaker();
		310	new TreeScanner<Void, Void>() {
		311	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
		312	workingCopy.rewrite(node, make.removeLambdaParameter(node, 0));
		313	return super.visitLambdaExpression(node, p);
		314	}
		315	}.scan(workingCopy.getCompilationUnit(), null);
		316	}
		317
		318	};
		319	src.runModificationTask(task).commit();
		320	String res = TestUtilities.copyFileToString(testFile);
		321	System.err.println(res);
		322	assertEquals(golden, res);
		323	}
		324
		325	public void testRemoveSecondLambdaParam() throws Exception {
		326	testFile = new File(getWorkDir(), "Test.java");
		327	TestUtilities.copyStringToFile(testFile,
		328	"package hierbas.del.litoral;\n\n" +
		329	"public class Test {\n" +
		330	" public static void taragui() {\n" +
		331	" ChangeListener l = (e, f) -> {};\n" +
		332	" }\n" +
		333	"}\n"
		334	);
		335	String golden =
		336	"package hierbas.del.litoral;\n\n" +
		337	"public class Test {\n" +
		338	" public static void taragui() {\n" +
		339	" ChangeListener l = (e) -> {};\n" +
		340	" }\n" +
		341	"}\n";
		342	JavaSource src = getJavaSource(testFile);
		343
		344	Task<WorkingCopy> task = new Task<WorkingCopy>() {
		345
		346	public void run(final WorkingCopy workingCopy) throws IOException {
		347	workingCopy.toPhase(Phase.RESOLVED);
		348	final TreeMaker make = workingCopy.getTreeMaker();
349	new TreeScanner<Void, Void>() {
350	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
351	workingCopy.rewrite(node, make.removeLambdaParameter(node, 1));
352	return super.visitLambdaExpression(node, p);
353	}
354	}.scan(workingCopy.getCompilationUnit(), null);
355	}
356
357	};
358	src.runModificationTask(task).commit();
359	String res = TestUtilities.copyFileToString(testFile);
360	System.err.println(res);
361	assertEquals(golden, res);
362	}
363
364	public void testOnlyLambdaParam() throws Exception {
365	testFile = new File(getWorkDir(), "Test.java");
366	TestUtilities.copyStringToFile(testFile,
367	"package hierbas.del.litoral;\n\n" +
368	"public class Test {\n" +
369	" public static void taragui() {\n" +
370	" ChangeListener l = (e) -> {};\n" +
371	" }\n" +
372	"}\n"
373	);
374	String golden =
375	"package hierbas.del.litoral;\n\n" +
376	"public class Test {\n" +
377	" public static void taragui() {\n" +
378	" ChangeListener l = () -> {};\n" +
379	" }\n" +
380	"}\n";
381	JavaSource src = getJavaSource(testFile);
382
383	Task<WorkingCopy> task = new Task<WorkingCopy>() {
384
385	public void run(final WorkingCopy workingCopy) throws IOException {
386	workingCopy.toPhase(Phase.RESOLVED);
387	final TreeMaker make = workingCopy.getTreeMaker();
388	new TreeScanner<Void, Void>() {
389	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
390	workingCopy.rewrite(node, make.removeLambdaParameter(node, 0));
391	return super.visitLambdaExpression(node, p);
392	}
393	}.scan(workingCopy.getCompilationUnit(), null);
394	}
395
396	};
397	src.runModificationTask(task).commit();
398	String res = TestUtilities.copyFileToString(testFile);
399	System.err.println(res);
400	assertEquals(golden, res);
401	}
402
403	public void testLambdaFullBody2Expression() throws Exception {
404	testFile = new File(getWorkDir(), "Test.java");
405	TestUtilities.copyStringToFile(testFile,
406	"package hierbas.del.litoral;\n\n" +
407	"public class Test {\n" +
408	" public static void taragui() {\n" +
409	" ChangeListener l = (e) -> {return 1;};\n" +
410	" }\n" +
411	"}\n"
412	);
413	String golden =
414	"package hierbas.del.litoral;\n\n" +
415	"public class Test {\n" +
416	" public static void taragui() {\n" +
417	" ChangeListener l = (e) -> 1;\n" +
418	" }\n" +
419	"}\n";
420	JavaSource src = getJavaSource(testFile);
421
422	Task<WorkingCopy> task = new Task<WorkingCopy>() {
423
424	public void run(final WorkingCopy workingCopy) throws IOException {
425	workingCopy.toPhase(Phase.RESOLVED);
426	final TreeMaker make = workingCopy.getTreeMaker();
427	new TreeScanner<Void, Void>() {
428	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
429	ReturnTree t = (ReturnTree) ((BlockTree) node.getBody()).getStatements().get(0);
430	workingCopy.rewrite(node, make.setLambdaBody(node, t.getExpression()));
431	return super.visitLambdaExpression(node, p);
432	}
433	}.scan(workingCopy.getCompilationUnit(), null);
434	}
435
436	};
437	src.runModificationTask(task).commit();
438	String res = TestUtilities.copyFileToString(testFile);
439	System.err.println(res);
440	assertEquals(golden, res);
441	}
442
443	public void testLambdaExpression2FullBody() throws Exception {
444	testFile = new File(getWorkDir(), "Test.java");
445	TestUtilities.copyStringToFile(testFile,
446	"package hierbas.del.litoral;\n\n" +
447	"public class Test {\n" +
448	" public static void taragui() {\n" +
449	" ChangeListener l = (e) -> 1;\n" +
450	" }\n" +
451	"}\n"
452	);
453	String golden =
454	"package hierbas.del.litoral;\n\n" +
455	"public class Test {\n" +
456	" public static void taragui() {\n" +
457	" ChangeListener l = (e) -> {\n" +
458	" return 1;\n" +
459	" };\n" +
460	" }\n" +
461	"}\n";
462	JavaSource src = getJavaSource(testFile);
463
464	Task<WorkingCopy> task = new Task<WorkingCopy>() {
465
466	public void run(final WorkingCopy workingCopy) throws IOException {
467	workingCopy.toPhase(Phase.RESOLVED);
468	final TreeMaker make = workingCopy.getTreeMaker();
469	new TreeScanner<Void, Void>() {
470	@Override public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
471	workingCopy.rewrite(node, make.setLambdaBody(node, make.Block(Collections.singletonList(make.Return((ExpressionTree) node.getBody())), false)));
472	return super.visitLambdaExpression(node, p);
473	}
474	}.scan(workingCopy.getCompilationUnit(), null);
475	}
476
477	};
478	src.runModificationTask(task).commit();
479	String res = TestUtilities.copyFileToString(testFile);
480	System.err.println(res);
481	assertEquals(golden, res);
482	}
483
484	public void testMethodReferenceDiff() throws Exception {
485	testFile = new File(getWorkDir(), "Test.java");
486	TestUtilities.copyStringToFile(testFile,
487	"package hierbas.del.litoral;\n\n" +
488	"public class Test {\n" +
489	" public static void taragui() {\n" +
490	" Runnable r = hierbas.del.litoral.Test :: taragui;\n" +
491	" }\n" +
492	"}\n"
493	);
494	String golden =
495	"package hierbas.del.litoral;\n\n" +
496	"public class Test {\n" +
497	" public static void taragui() {\n" +
498	" Runnable r = Test :: taragui;\n" +
499	" }\n" +
500	"}\n";
501	JavaSource src = getJavaSource(testFile);
502
503	Task<WorkingCopy> task = new Task<WorkingCopy>() {
504
505	public void run(final WorkingCopy workingCopy) throws IOException {
506	workingCopy.toPhase(Phase.RESOLVED);
507	final TreeMaker make = workingCopy.getTreeMaker();
508	new TreeScanner<Void, Void>() {
509	@Override public Void visitMemberReference(MemberReferenceTree node, Void p) {
510	workingCopy.rewrite(node, make.MemberReference(node.getMode(), make.Identifier("Test"), node.getName(), node.getTypeArguments()));
511	return super.visitMemberReference(node, p);
512	}
513	}.scan(workingCopy.getCompilationUnit(), null);
514	}
515
516	};
517	src.runModificationTask(task).commit();
518	String res = TestUtilities.copyFileToString(testFile);
519	System.err.println(res);
520	assertEquals(golden, res);
521	}
522
523	public void testMethodReferenceNameDiff() throws Exception {
524	testFile = new File(getWorkDir(), "Test.java");
525	TestUtilities.copyStringToFile(testFile,
526	"package hierbas.del.litoral;\n\n" +
527	"public class Test {\n" +
528	" public static void taragui() {\n" +
529	" Runnable r = Test :: taragui;\n" +
530	" }\n" +
531	"}\n"
532	);
533	String golden =
534	"package hierbas.del.litoral;\n\n" +
535	"public class Test {\n" +
536	" public static void taragui() {\n" +
537	" Runnable r = Test :: taragui2;\n" +
538	" }\n" +
539	"}\n";
540	JavaSource src = getJavaSource(testFile);
541
542	Task<WorkingCopy> task = new Task<WorkingCopy>() {
543
544	public void run(final WorkingCopy workingCopy) throws IOException {
545	workingCopy.toPhase(Phase.RESOLVED);
546	final TreeMaker make = workingCopy.getTreeMaker();
547	new TreeScanner<Void, Void>() {
548	@Override public Void visitMemberReference(MemberReferenceTree node, Void p) {
549	workingCopy.rewrite(node, make.setLabel(node, "taragui2"));
550	return super.visitMemberReference(node, p);
551	}
552	}.scan(workingCopy.getCompilationUnit(), null);
553	}
554
555	};
556	src.runModificationTask(task).commit();
557	String res = TestUtilities.copyFileToString(testFile);
558	System.err.println(res);
559	assertEquals(golden, res);
560	}
561
562	public void testMethodReferenceFirstTypeParam() throws Exception {
563	testFile = new File(getWorkDir(), "Test.java");
564	TestUtilities.copyStringToFile(testFile,
565	"package hierbas.del.litoral;\n\n" +
566	"public class Test {\n" +
567	" public static void taragui() {\n" +
568	" Runnable r = Test::taragui;\n" +
569	" }\n" +
570	"}\n"
571	);
572	String golden =
573	"package hierbas.del.litoral;\n\n" +
574	"public class Test {\n" +
575	" public static void taragui() {\n" +
576	" Runnable r = Test::<String>taragui;\n" +
577	" }\n" +
578	"}\n";
579	JavaSource src = getJavaSource(testFile);
580
581	Task<WorkingCopy> task = new Task<WorkingCopy>() {
582
583	public void run(final WorkingCopy workingCopy) throws IOException {
584	workingCopy.toPhase(Phase.RESOLVED);
585	final TreeMaker make = workingCopy.getTreeMaker();
586	new TreeScanner<Void, Void>() {
587	@Override public Void visitMemberReference(MemberReferenceTree node, Void p) {
588	workingCopy.rewrite(node, make.MemberReference(node.getMode(), node.getQualifierExpression(), node.getName(), Collections.singletonList(make.Identifier("String"))));
589	return super.visitMemberReference(node, p);
590	}
591	}.scan(workingCopy.getCompilationUnit(), null);
592	}
593
594	};
595	src.runModificationTask(task).commit();
596	String res = TestUtilities.copyFileToString(testFile);
597	System.err.println(res);
598	assertEquals(golden, res);
599	}
600
601	public void testMethodReferenceLastTypeParam() throws Exception {
602	testFile = new File(getWorkDir(), "Test.java");
603	TestUtilities.copyStringToFile(testFile,
604	"package hierbas.del.litoral;\n\n" +
605	"public class Test {\n" +
606	" public static void taragui() {\n" +
607	" Runnable r = Test::<String>taragui;\n" +
608	" }\n" +
609	"}\n"
610	);
611	String golden =
612	"package hierbas.del.litoral;\n\n" +
613	"public class Test {\n" +
614	" public static void taragui() {\n" +
615	" Runnable r = Test::taragui;\n" +
616	" }\n" +
617	"}\n";
618	JavaSource src = getJavaSource(testFile);
619
620	Task<WorkingCopy> task = new Task<WorkingCopy>() {
621
622	public void run(final WorkingCopy workingCopy) throws IOException {
623	workingCopy.toPhase(Phase.RESOLVED);
624	final TreeMaker make = workingCopy.getTreeMaker();
625	new TreeScanner<Void, Void>() {
626	@Override public Void visitMemberReference(MemberReferenceTree node, Void p) {
627	workingCopy.rewrite(node, make.MemberReference(node.getMode(), node.getQualifierExpression(), node.getName(), null));
628	return super.visitMemberReference(node, p);
629	}
630	}.scan(workingCopy.getCompilationUnit(), null);
631	}
632
633	};
634	src.runModificationTask(task).commit();
635	String res = TestUtilities.copyFileToString(testFile);
636	System.err.println(res);
637	assertEquals(golden, res);
638	}
349		639
350	String getGoldenPckg() {	640	String getGoldenPckg() {
351	return "";	641	return "";

Lines 42-53 Link Here

(-)a/java.source/test/unit/src/org/netbeans/modules/java/source/parsing/JavacParserTest.java (+67 lines)
42		42
43	package org.netbeans.modules.java.source.parsing;	43	package org.netbeans.modules.java.source.parsing;
44		44
		45	import com.sun.source.tree.CompilationUnitTree;
		46	import com.sun.source.tree.Tree;
		47	import com.sun.source.util.TreePath;
		48	import com.sun.source.util.TreePathScanner;
45	import java.io.File;	49	import java.io.File;
46	import java.util.Arrays;	50	import java.util.Arrays;
47	import java.util.HashSet;	51	import java.util.HashSet;
48	import java.util.Set;	52	import java.util.Set;
		53	import java.util.concurrent.atomic.AtomicReference;
49	import javax.lang.model.element.TypeElement;	54	import javax.lang.model.element.TypeElement;
		55	import javax.swing.text.Document;
50	import javax.tools.Diagnostic;	56	import javax.tools.Diagnostic;
		57	import static junit.framework.Assert.assertTrue;
		58	import org.netbeans.api.java.lexer.JavaTokenId;
51	import org.netbeans.api.java.source.ClasspathInfo;	59	import org.netbeans.api.java.source.ClasspathInfo;
52	import org.netbeans.api.java.source.CompilationController;	60	import org.netbeans.api.java.source.CompilationController;
53	import org.netbeans.api.java.source.JavaSource;	61	import org.netbeans.api.java.source.JavaSource;
Lines 55-64 Link Here
55	import org.netbeans.api.java.source.SourceUtilsTestUtil;	63	import org.netbeans.api.java.source.SourceUtilsTestUtil;
56	import org.netbeans.api.java.source.Task;	64	import org.netbeans.api.java.source.Task;
57	import org.netbeans.api.java.source.TestUtilities;	65	import org.netbeans.api.java.source.TestUtilities;
		66	import org.netbeans.api.lexer.Language;
		67	import org.netbeans.api.lexer.TokenHierarchy;
		68	import org.netbeans.api.lexer.TokenSequence;
58	import org.netbeans.junit.NbTestCase;	69	import org.netbeans.junit.NbTestCase;
59	import org.netbeans.modules.java.source.tasklist.CompilerSettings;	70	import org.netbeans.modules.java.source.tasklist.CompilerSettings;
		71	import org.openide.cookies.EditorCookie;
60	import org.openide.filesystems.FileObject;	72	import org.openide.filesystems.FileObject;
61	import org.openide.filesystems.FileUtil;	73	import org.openide.filesystems.FileUtil;
		74	import org.openide.loaders.DataObject;
62		75
63	/**	76	/**
64	*	77	*
Lines 126-131 Link Here
126	}	139	}
127	}, true);	140	}, true);
128	}	141	}
		142
		143	public void testPartialReparse() throws Exception {
		144	FileObject f2 = createFile("test/Test2.java", "package test; class Test2 { private void test() { System.err.println(\"\"); System.err.println(1); } }");
		145	DataObject d = DataObject.find(f2);
		146	EditorCookie ec = d.getLookup().lookup(EditorCookie.class);
		147	Document doc = ec.openDocument();
		148	JavaSource js = JavaSource.forFileObject(f2);
		149
		150	doc.putProperty(Language.class, JavaTokenId.language());
		151
		152	//initialize the tokens hierarchy:
		153	TokenSequence<?> ts = TokenHierarchy.get(doc).tokenSequence();
		154
		155	ts.moveStart();
		156
		157	while (ts.moveNext());
		158
		159	final AtomicReference<CompilationUnitTree> tree = new AtomicReference<CompilationUnitTree>();
		160
		161	js.runUserActionTask(new Task<CompilationController>() {
		162	public void run(CompilationController parameter) throws Exception {
		163	assertTrue(Phase.RESOLVED.compareTo(parameter.toPhase(Phase.RESOLVED)) <= 0);
		164	tree.set(parameter.getCompilationUnit());
		165	}
		166	}, true);
		167
		168	doc.insertString(doc.getText(0, doc.getLength()).indexOf("\"") + 1, "aaaaaaaa", null);
		169
		170	js.runUserActionTask(new Task<CompilationController>() {
		171	public void run(final CompilationController parameter) throws Exception {
		172	assertTrue(Phase.RESOLVED.compareTo(parameter.toPhase(Phase.RESOLVED)) <= 0);
		173
		174	assertSame(tree.get(), parameter.getCompilationUnit());
		175
		176	new TreePathScanner<Void, long[]>() {
		177
		178	@Override
		179	public Void scan(Tree tree, long[] parentSpan) {
		180	if (tree == null) return null;
		181	if (parameter.getTreeUtilities().isSynthetic(new TreePath(getCurrentPath(), tree))) return null;
		182	long start = parameter.getTrees().getSourcePositions().getStartPosition(parameter.getCompilationUnit(), tree);
		183	long end = parameter.getTrees().getSourcePositions().getEndPosition(parameter.getCompilationUnit(), tree);
		184	assertTrue(start <= end);
		185	if (parentSpan != null) {
		186	assertTrue(parentSpan[0] <= start);
		187	assertTrue(end <= parentSpan[1]);
		188	}
		189	return super.scan(tree, new long[] {start, end});
		190	}
		191
		192	}.scan(parameter.getCompilationUnit(), null);
		193	}
		194	}, true);
		195	}
129		196
130	private FileObject createFile(String path, String content) throws Exception {	197	private FileObject createFile(String path, String content) throws Exception {
131	FileObject file = FileUtil.createData(sourceRoot, path);	198	FileObject file = FileUtil.createData(sourceRoot, path);




        reformat(doc, content, golden);
    }

    public void testLambdaParameterWithInferredType() throws Exception {
        testFile = new File(getWorkDir(), "Test.java");
        TestUtilities.copyStringToFile(testFile, "");
        FileObject testSourceFO = FileUtil.toFileObject(testFile);
        DataObject testSourceDO = DataObject.find(testSourceFO);
        EditorCookie ec = (EditorCookie)testSourceDO.getCookie(EditorCookie.class);
        final Document doc = ec.openDocument();
        doc.putProperty(Language.class, JavaTokenId.language());
        String content =
                "package hierbas.del.litoral;\n\n"
                + "public class Test {\n\n"
                + "    public static void main(String[] args) {\n"
                + "        java.util.Arrays.asList(args).map((val) -> val.length());\n"
                + "    }\n"
                + "}\n";

        String golden =
                "package hierbas.del.litoral;\n\n"
                + "public class Test {\n\n"
                + "    public static void main(String[] args) {\n"
                + "        java.util.Arrays.asList(args).map((val) -> val.length());\n"
                + "    }\n"
                + "}\n";
        reformat(doc, content, golden);
    }

    private void reformat(Document doc, String content, String golden) throws Exception {
        reformat(doc, content, golden, 0, content.length());
    }

Return to bug 225533

Lines 626-632 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/indexing/JavaCustomIndexer.java (-4 / +7 lines)
626		626
627	static void setErrors(Context context, CompileTuple active, DiagnosticListenerImpl errors) {	627	static void setErrors(Context context, CompileTuple active, DiagnosticListenerImpl errors) {
628	if (!active.virtual) {	628	if (!active.virtual) {
629	Iterable<Diagnostic<? extends JavaFileObject>> filteredErrorsList = Iterators.filter(errors.getDiagnostics(active.jfo), new FilterOutDiamondWarnings());	629	Iterable<Diagnostic<? extends JavaFileObject>> filteredErrorsList = Iterators.filter(errors.getDiagnostics(active.jfo), new FilterOutJDK7AndLaterWarnings());
630	ErrorsCache.setErrors(context.getRootURI(), active.indexable, filteredErrorsList, active.aptGenerated ? ERROR_CONVERTOR_NO_BADGE : ERROR_CONVERTOR);	630	ErrorsCache.setErrors(context.getRootURI(), active.indexable, filteredErrorsList, active.aptGenerated ? ERROR_CONVERTOR_NO_BADGE : ERROR_CONVERTOR);
631	}	631	}
632	}	632	}
Lines 1171-1181 Link Here
1171	return result;	1171	return result;
1172	}	1172	}
1173		1173
1174	private static final Set<String> DIAMOND_KINDS = new HashSet<String>(Arrays.asList("compiler.warn.diamond.redundant.args", "compiler.warn.diamond.redundant.args.1"));	1174	private static final Set<String> JDK7AndLaterWarnings = new HashSet<String>(Arrays.asList(
		1175	"compiler.warn.diamond.redundant.args",
		1176	"compiler.warn.diamond.redundant.args.1",
		1177	"compiler.note.potential.lambda.found"));
1175		1178
1176	private static class FilterOutDiamondWarnings implements Comparable<Diagnostic<? extends JavaFileObject>> {	1179	private static class FilterOutJDK7AndLaterWarnings implements Comparable<Diagnostic<? extends JavaFileObject>> {
1177	@Override public int compareTo(Diagnostic<? extends JavaFileObject> o) {	1180	@Override public int compareTo(Diagnostic<? extends JavaFileObject> o) {
1178	return DIAMOND_KINDS.contains(o.getCode()) ? 0 : -1;	1181	return JDK7AndLaterWarnings.contains(o.getCode()) ? 0 : -1;
1179	}	1182	}
1180	}	1183	}
1181		1184

Lines 4227-4232 Link Here

(-)a/java.source/test/unit/src/org/netbeans/modules/java/source/save/FormatingTest.java (+26 lines)
4227	reformat(doc, content, golden);	4227	reformat(doc, content, golden);
4228	}	4228	}
4229		4229
		4230	public void testLambdaParameterWithInferredType() throws Exception {
		4231	testFile = new File(getWorkDir(), "Test.java");
		4232	TestUtilities.copyStringToFile(testFile, "");
		4233	FileObject testSourceFO = FileUtil.toFileObject(testFile);
		4234	DataObject testSourceDO = DataObject.find(testSourceFO);
		4235	EditorCookie ec = (EditorCookie)testSourceDO.getCookie(EditorCookie.class);
		4236	final Document doc = ec.openDocument();
		4237	doc.putProperty(Language.class, JavaTokenId.language());
		4238	String content =
		4239	"package hierbas.del.litoral;\n\n"
		4240	+ "public class Test {\n\n"
		4241	+ " public static void main(String[] args) {\n"
		4242	+ " java.util.Arrays.asList(args).map((val) -> val.length());\n"
		4243	+ " }\n"
		4244	+ "}\n";
		4245
		4246	String golden =
		4247	"package hierbas.del.litoral;\n\n"
		4248	+ "public class Test {\n\n"
		4249	+ " public static void main(String[] args) {\n"
		4250	+ " java.util.Arrays.asList(args).map((val) -> val.length());\n"
		4251	+ " }\n"
		4252	+ "}\n";
		4253	reformat(doc, content, golden);
		4254	}
		4255
4230	private void reformat(Document doc, String content, String golden) throws Exception {	4256	private void reformat(Document doc, String content, String golden) throws Exception {
4231	reformat(doc, content, golden, 0, content.length());	4257	reformat(doc, content, golden, 0, content.length());
4232	}	4258	}

Lines 108-113 Link Here

(-)a/java.source/apichanges.xml (+14 lines)
108	<!-- ACTUAL CHANGES BEGIN HERE: -->	108	<!-- ACTUAL CHANGES BEGIN HERE: -->
109		109
110	<changes>	110	<changes>
		111	<change id="LambdaEnhancements">
		112	<api name="general"/>
		113	<summary>Added several methods to support Java 8 features.</summary>
		114	<version major="0" minor="112"/>
		115	<date day="13" month="2" year="2013"/>
		116	<author login="jlahoda"/>
		117	<compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible"/>
		118	<description>
		119	Added several new methods to support Java 8 features. Namely: <code>ElementUtilities.isEffectivelyFinal</code>,
		120	<code>TreeMaker.TypeAnnotation</code>, <code>TreeMaker.LambdaExpression</code>,
		121	<code>TreeMaker.MemberReference</code> and <code>TypeUtilities.getDescriptorType</code>.
		122	</description>
		123	<issue number="225533"/>
		124	</change>
111	<change id="SourceUtils-getDependentRoots">	125	<change id="SourceUtils-getDependentRoots">
112	<api name="general"/>	126	<api name="general"/>
113	<summary>Added overloaded method <code>SourceUtils.getDependentRoots</code>.</summary>	127	<summary>Added overloaded method <code>SourceUtils.getDependentRoots</code>.</summary>

Lines 46-52 Link Here

(-)a/java.source/nbproject/project.properties (-1 / +2 lines)
46	javadoc.title=Java Source	46	javadoc.title=Java Source
47	javadoc.arch=${basedir}/arch.xml	47	javadoc.arch=${basedir}/arch.xml
48	javadoc.apichanges=${basedir}/apichanges.xml	48	javadoc.apichanges=${basedir}/apichanges.xml
49	spec.version.base=0.111.0	49	spec.version.base=0.112
50	test.qa-functional.cp.extra=${refactoring.java.dir}/modules/ext/nb-javac-api.jar	50	test.qa-functional.cp.extra=${refactoring.java.dir}/modules/ext/nb-javac-api.jar
51	test.unit.run.cp.extra=${o.n.core.dir}/core/core.jar:\	51	test.unit.run.cp.extra=${o.n.core.dir}/core/core.jar:\
52	${o.n.core.dir}/lib/boot.jar:\	52	${o.n.core.dir}/lib/boot.jar:\
Lines 148-153 Link Here
148	${test.config.generator.includes},\	148	${test.config.generator.includes},\
149	org/netbeans/api/java/source/TypeUtilitiesTest.class,\	149	org/netbeans/api/java/source/TypeUtilitiesTest.class,\
150	org/netbeans/api/java/source/TreePathHandleTest.class,\	150	org/netbeans/api/java/source/TreePathHandleTest.class,\
		151	org/netbeans/api/java/source/TreeMirrorHandleTest.class,\
151	org/netbeans/api/java/source/ModificationResultTest.class,\	152	org/netbeans/api/java/source/ModificationResultTest.class,\
152	org/netbeans/api/java/source/ScanUtilsTest.class,\	153	org/netbeans/api/java/source/ScanUtilsTest.class,\
153	org/netbeans/modules/java/source/save/FormatingTest.class,\	154	org/netbeans/modules/java/source/save/FormatingTest.class,\

Lines 88-93 Link Here

(-)a/java.source/src/org/netbeans/api/java/source/ElementUtilities.java (+13 lines)
88	import javax.lang.model.element.Modifier;	88	import javax.lang.model.element.Modifier;
89	import javax.lang.model.element.TypeElement;	89	import javax.lang.model.element.TypeElement;
90	import javax.lang.model.element.TypeParameterElement;	90	import javax.lang.model.element.TypeParameterElement;
		91	import javax.lang.model.element.VariableElement;
91	import javax.lang.model.type.DeclaredType;	92	import javax.lang.model.type.DeclaredType;
92	import javax.lang.model.type.ExecutableType;	93	import javax.lang.model.type.ExecutableType;
93	import javax.lang.model.type.TypeKind;	94	import javax.lang.model.type.TypeKind;
Lines 260-265 Link Here
260	case DECLARED:	261	case DECLARED:
261	case UNION:	262	case UNION:
262	TypeElement te = (TypeElement)((DeclaredType)type).asElement();	263	TypeElement te = (TypeElement)((DeclaredType)type).asElement();
		264	if (te == null) break;
263	for (Element member : elements.getAllMembers(te)) {	265	for (Element member : elements.getAllMembers(te)) {
264	if (acceptor == null \|\| acceptor.accept(member, type)) {	266	if (acceptor == null \|\| acceptor.accept(member, type)) {
265	if (!isHidden(member, members, elements, types))	267	if (!isHidden(member, members, elements, types))
Lines 534-539 Link Here
534	}	536	}
535	return false;	537	return false;
536	}	538	}
		539
		540	/** Check whether the given variable is effectively final or final.
		541	*
		542	* @param e variable to check for effectively final status
		543	* @return true if the given variable is effectively final or final
		544	* @since 0.112
		545	*/
		546	public boolean isEffectivelyFinal(VariableElement e) {
		547	return (((Symbol) e).flags() & (Flags.EFFECTIVELY_FINAL \| Flags.FINAL)) != 0;
		548	};
		549
537	// private implementation --------------------------------------------------	550	// private implementation --------------------------------------------------
538		551
539		552

Lines 46-51 Link Here

(-)a/java.source/src/org/netbeans/api/java/source/TreeMaker.java (-2 / +121 lines)
46	import com.sun.source.tree.*;	46	import com.sun.source.tree.*;
47	import org.netbeans.modules.java.source.parsing.FileObjects;	47	import org.netbeans.modules.java.source.parsing.FileObjects;
48	import org.openide.filesystems.FileObject;	48	import org.openide.filesystems.FileObject;
		49	import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
49	import static com.sun.source.tree.Tree.*;	50	import static com.sun.source.tree.Tree.*;
50		51
51	import com.sun.source.util.SourcePositions;	52	import com.sun.source.util.SourcePositions;
Lines 133-138 Link Here
133	return delegate.Annotation(type, arguments);	134	return delegate.Annotation(type, arguments);
134	}	135	}
135		136
		137	/**
		138	* Creates a new type AnnotationTree.
		139	*
		140	* @param type the annotation type.
		141	* @param arguments the arguments for this annotation, or an empty list.
		142	* @see com.sun.source.tree.AnnotationTree
		143	* @since 0.112
		144	*/
		145	public AnnotationTree TypeAnnotation(Tree type, List<? extends ExpressionTree> arguments) {
		146	return delegate.TypeAnnotation(type, arguments);
		147	}
		148
136	/**	149	/**
137	* Creates a new ArrayAccessTree.	150	* Creates a new ArrayAccessTree.
138	*	151	*
Lines 620-626 Link Here
620	public LabeledStatementTree LabeledStatement(CharSequence label, StatementTree statement) {	633	public LabeledStatementTree LabeledStatement(CharSequence label, StatementTree statement) {
621	return delegate.LabeledStatement(label, statement);	634	return delegate.LabeledStatement(label, statement);
622	}	635	}
623		636
		637	/**Creates a new LambdaExpressionTree
		638	*
		639	* @param parameters the lambda's formal arguments
		640	* @param body the lambda's body
		641	* @return the LambdaExpressionTree
		642	* @since 0.112
		643	*/
		644	public LambdaExpressionTree LambdaExpression(List<? extends VariableTree> parameters, Tree body) {
		645	return delegate.LambdaExpression(parameters, body);
		646	}
		647
624	/**	648	/**
625	* Creates a new LiteralTree. Only literals which are wrappers for	649	* Creates a new LiteralTree. Only literals which are wrappers for
626	* primitive types (Integer, Boolean, etc.) and String instances can	650	* primitive types (Integer, Boolean, etc.) and String instances can
Lines 634-639 Link Here
634	return delegate.Literal(value);	658	return delegate.Literal(value);
635	}	659	}
636		660
		661	/**Creates a new MemberReferenceTree.
		662	*
		663	* @param refMode the desired {@link ReferenceMode reference mode}
		664	* @param expression the class (or expression), from which a member is to be referenced
		665	* @param name the name of the referenced member
		666	* @param typeArguments the reference's type arguments
		667	* @return the MemberReferenceTree
		668	* @since 0.112
		669	*/
		670	public MemberReferenceTree MemberReference(ReferenceMode refMode, ExpressionTree expression, CharSequence name, List<? extends ExpressionTree> typeArguments) {
		671	return delegate.MemberReference(refMode, name, expression, typeArguments);
		672	}
		673
637	/**	674	/**
638	* Creates a new MemberSelectTree. A MemberSelectTree consists of an	675	* Creates a new MemberSelectTree. A MemberSelectTree consists of an
639	* expression and an identifier. Valid expressions include things like	676	* expression and an identifier. Valid expressions include things like
Lines 2573-2579 Link Here
2573	* <tt>aLabel</tt> argument. Throws <tt>IllegalArgumentException</tt> if	2610	* <tt>aLabel</tt> argument. Throws <tt>IllegalArgumentException</tt> if
2574	* <tt>node</tt>'s kind is invalid. Valid <tt>node</tt>'s kinds are:<br>	2611	* <tt>node</tt>'s kind is invalid. Valid <tt>node</tt>'s kinds are:<br>
2575	* BREAK, CLASS, CONTINUE, IDENTIFIER, LABELED_STATEMENT,	2612	* BREAK, CLASS, CONTINUE, IDENTIFIER, LABELED_STATEMENT,
2576	* MEMBER_SELECT, METHOD, TYPE_PARAMETER, VARIABLE.<p>	2613	* MEMBER_SELECT, METHOD, TYPE_PARAMETER, VARIABLE, MEMBER_REFERENCE (since 0.112).<p>
2577	*	2614	*
2578	* Consider you want to change name of method <tt>fooMet</tt> to	2615	* Consider you want to change name of method <tt>fooMet</tt> to
2579	* <tt>fooMethod</tt>:	2616	* <tt>fooMethod</tt>:
Lines 2703-2708 Link Here
2703	);	2740	);
2704	return clone;	2741	return clone;
2705	}	2742	}
		2743	case MEMBER_REFERENCE: {
		2744	MemberReferenceTree t = (MemberReferenceTree) node;
		2745	N clone = (N) MemberReference(
		2746	t.getMode(),
		2747	t.getQualifierExpression(),
		2748	aLabel,
		2749	t.getTypeArguments()
		2750	);
		2751	return clone;
		2752	}
2706	case METHOD: {	2753	case METHOD: {
2707	MethodTree t = (MethodTree) node;	2754	MethodTree t = (MethodTree) node;
2708	N clone = (N) Method(	2755	N clone = (N) Method(
Lines 3062-3065 Link Here
3062	}	3109	}
3063		3110
3064	}	3111	}
		3112
		3113	/**
		3114	* Appends specified element <tt>parameter</tt>
		3115	* to the end of parameters list.
		3116	*
		3117	* @param method lambda expression tree containing parameters list.
		3118	* @param parameter element to be appended to parameters list.
		3119	* @return lambda expression tree with modified parameters.
		3120	* @since 0.112
		3121	*/
		3122	public LambdaExpressionTree addLambdaParameter(LambdaExpressionTree method, VariableTree parameter) {
		3123	return delegate.addLambdaParameter(method, parameter);
		3124	}
		3125
		3126	/**
		3127	* Inserts the specified element <tt>parameter</tt>
		3128	* at the specified position in parameters list.
		3129	*
		3130	* @param method lambda expression tree containing parameters list.
		3131	* @param index index at which the specified elements is to be inserted.
		3132	* @param parameter element to be inserted to parameters list.
		3133	* @return lambda expression tree with modified parameters.
		3134	*
		3135	* @throws IndexOutOfBoundsException if the index is out of range
		3136	* (index < 0 \|\| index > size()).
		3137	* @since 0.112
		3138	*/
		3139	public LambdaExpressionTree insertLambdaParameter(LambdaExpressionTree method, int index, VariableTree parameter) {
		3140	return delegate.insertLambdaParameter(method, index, parameter);
		3141	}
		3142
		3143	/**
		3144	* Removes the first occurrence in parameters list of the specified
		3145	* elements. If this list do not contain the element, it is
		3146	* unchanged.
		3147	*
		3148	* @param method lambda expression tree containing parameters list.
		3149	* @param parameter element to be removed from this list, if present.
		3150	* @return lambda expression tree with modified parameters and type parameters.
		3151	* @since 0.112
		3152	*/
		3153	public LambdaExpressionTree removeLambdaParameter(LambdaExpressionTree method, VariableTree parameter) {
		3154	return delegate.removeLambdaParameter(method, parameter);
		3155	}
		3156
		3157	/**
		3158	* Removes the element at the specified position in parameters list.
		3159	* Returns the modified lambda expression tree.
		3160	*
		3161	* @param method lambda expression tree containing parameters list.
		3162	* @param index the index of the element to be removed.
		3163	* @return method tree with modified parameters.
		3164	*
		3165	* @throws IndexOutOfBoundsException if the index is out of range (index
		3166	* < 0 \|\| index >= size()).
		3167	* @since 0.112
		3168	*/
		3169	public LambdaExpressionTree removeLambdaParameter(LambdaExpressionTree method, int index) {
		3170	return delegate.removeLambdaParameter(method, index);
		3171	}
		3172
		3173	/**Creates a new lambda expression as a copy of the given lambda expression
		3174	* with the specified body.
		3175	*
3176	* @param method the source lambda expression
3177	* @param newBody the new body
3178	* @return new lambda expression tree with the new body
3179	* @since 0.112
3180	*/
3181	public LambdaExpressionTree setLambdaBody(LambdaExpressionTree method, Tree newBody) {
3182	return delegate.setLambdaBody(method, newBody);
3183	}
3065	}	3184	}

Lines 50-59 Link Here

(-)a/java.source/src/org/netbeans/api/java/source/TypeMirrorHandle.java (-3 / +24 lines)
50	import com.sun.tools.javac.code.Type;	50	import com.sun.tools.javac.code.Type;
51	import com.sun.tools.javac.code.Type.ClassType;	51	import com.sun.tools.javac.code.Type.ClassType;
52	import com.sun.tools.javac.code.Type.TypeVar;	52	import com.sun.tools.javac.code.Type.TypeVar;
53	import com.sun.tools.javac.code.TypeTags;	53	import com.sun.tools.javac.code.TypeTag;
54	import com.sun.tools.javac.code.Types;	54	import com.sun.tools.javac.code.Types;
55	import com.sun.tools.javac.code.Types.DefaultTypeVisitor;	55	import com.sun.tools.javac.code.Types.DefaultTypeVisitor;
56	import com.sun.tools.javac.util.Context;	56	import com.sun.tools.javac.util.Context;
		57	import com.sun.tools.javac.util.ListBuffer;
57	import com.sun.tools.javac.util.Names;	58	import com.sun.tools.javac.util.Names;
58	import java.util.ArrayList;	59	import java.util.ArrayList;
59	import java.util.Collections;	60	import java.util.Collections;
Lines 68-73 Link Here
68	import javax.lang.model.type.ArrayType;	69	import javax.lang.model.type.ArrayType;
69	import javax.lang.model.type.DeclaredType;	70	import javax.lang.model.type.DeclaredType;
70	import javax.lang.model.type.ErrorType;	71	import javax.lang.model.type.ErrorType;
		72	import javax.lang.model.type.IntersectionType;
71	import javax.lang.model.type.ReferenceType;	73	import javax.lang.model.type.ReferenceType;
72	import javax.lang.model.type.TypeKind;	74	import javax.lang.model.type.TypeKind;
73	import javax.lang.model.type.TypeMirror;	75	import javax.lang.model.type.TypeMirror;
Lines 224-229 Link Here
224	typeMirrors.add(create(alternative, map));	226	typeMirrors.add(create(alternative, map));
225	}	227	}
226	break;	228	break;
		229	case INTERSECTION:
		230	typeMirrors = new ArrayList<TypeMirrorHandle<? extends TypeMirror>>();
		231	for (TypeMirror alternative : ((IntersectionType) tm).getBounds()) {
		232	typeMirrors.add(create(alternative, map));
		233	}
		234	break;
227	default:	235	default:
228	throw new IllegalArgumentException("Currently unsupported TypeKind: " + tm.getKind());	236	throw new IllegalArgumentException("Currently unsupported TypeKind: " + tm.getKind());
229	}	237	}
Lines 378-386 Link Here
378	t = Types.instance(info.impl.getJavacTask().getContext());	386	t = Types.instance(info.impl.getJavacTask().getContext());
379	Type lub = t.lub(resolvedAlternatives);	387	Type lub = t.lub(resolvedAlternatives);
380		388
381	if (lub.tag != TypeTags.CLASS) return null;	389	if (!lub.hasTag(TypeTag.CLASS)) return null;
382		390
383	return (T) new Type.UnionClassType((ClassType) lub, resolvedAlternatives);	391	return (T) new Type.UnionClassType((ClassType) lub, resolvedAlternatives);
		392	case INTERSECTION:
		393	ListBuffer<Type> resolvedBounds = new ListBuffer<Type>();
		394	for (TypeMirrorHandle alternative : typeMirrors) {
		395	TypeMirror resolvedAlternative = alternative.resolve(info, map);
		396	if (resolvedAlternative == null) {
		397	return null;
		398	}
		399	resolvedBounds = resolvedBounds.append((Type) resolvedAlternative);
		400	}
		401
		402	t = Types.instance(info.impl.getJavacTask().getContext());
		403
		404	return (T) t.makeCompoundType(resolvedBounds.toList());
384	default:	405	default:
385	throw new IllegalStateException("Internal error: unknown TypeHandle kind: " + kind);	406	throw new IllegalStateException("Internal error: unknown TypeHandle kind: " + kind);
386	}	407	}
Lines 405-411 Link Here
405	private Type delegate = null;	426	private Type delegate = null;
406		427
407	public PlaceholderType() {	428	public PlaceholderType() {
408	super(TypeTags.UNKNOWN, null);	429	super(TypeTag.UNKNOWN, null);
409	}	430	}
410	}	431	}
411		432

Lines 73-78 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/TreeLoader.java (-4 / +4 lines)
73	import com.sun.tools.javac.util.CouplingAbort;	73	import com.sun.tools.javac.util.CouplingAbort;
74	import com.sun.tools.javac.util.List;	74	import com.sun.tools.javac.util.List;
75	import com.sun.tools.javac.util.Log;	75	import com.sun.tools.javac.util.Log;
		76	import com.sun.tools.javac.util.Log.DiscardDiagnosticHandler;
76	import java.awt.EventQueue;	77	import java.awt.EventQueue;
77	import java.io.File;	78	import java.io.File;
78	import java.io.FileOutputStream;	79	import java.io.FileOutputStream;
Lines 307-313 Link Here
307	List<JCTree> prev = null;	308	List<JCTree> prev = null;
308	for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {	309	for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
309	scan(l.head);	310	scan(l.head);
310	if (l.head.getTag() == JCTree.BLOCK) {	311	if (l.head.getTag() == JCTree.Tag.BLOCK) {
311	if (prev != null)	312	if (prev != null)
312	prev.tail = l.tail;	313	prev.tail = l.tail;
313	else	314	else
Lines 326-333 Link Here
326	public static void dumpSymFile(JavaFileManager jfm, JavacTaskImpl jti, ClassSymbol clazz) throws IOException {	327	public static void dumpSymFile(JavaFileManager jfm, JavacTaskImpl jti, ClassSymbol clazz) throws IOException {
327	Log log = Log.instance(jti.getContext());	328	Log log = Log.instance(jti.getContext());
328	JavaFileObject prevLogTo = log.useSource(null);	329	JavaFileObject prevLogTo = log.useSource(null);
329	boolean oldSuppress = log.suppressErrorsAndWarnings;	330	DiscardDiagnosticHandler discardDiagnosticHandler = new Log.DiscardDiagnosticHandler(log);
330	log.suppressErrorsAndWarnings = true;
331	try {	331	try {
332	String binaryName = null;	332	String binaryName = null;
333	String surl = null;	333	String surl = null;
Lines 364-370 Link Here
364	LOGGER.log(Level.INFO, "InvalidSourcePath reported when writing sym file for class: {0}", clazz.flatname); // NOI18N	364	LOGGER.log(Level.INFO, "InvalidSourcePath reported when writing sym file for class: {0}", clazz.flatname); // NOI18N
365	} finally {	365	} finally {
366	jfm.handleOption("output-root", Collections.singletonList("").iterator()); //NOI18N	366	jfm.handleOption("output-root", Collections.singletonList("").iterator()); //NOI18N
367	log.suppressErrorsAndWarnings = oldSuppress;	367	log.popDiagnosticHandler(discardDiagnosticHandler);
368	log.useSource(prevLogTo);	368	log.useSource(prevLogTo);
369	}	369	}
370	}	370	}

Lines 48-61 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/builder/ElementsService.java (-5 / +4 lines)
48	import com.sun.tools.javac.util.Name;	48	import com.sun.tools.javac.util.Name;
49	import com.sun.tools.javac.util.Names;	49	import com.sun.tools.javac.util.Names;
50	import javax.lang.model.util.Types;	50	import javax.lang.model.util.Types;
51	import org.netbeans.api.java.source.*;
52	import com.sun.tools.javac.code.Scope;	51	import com.sun.tools.javac.code.Scope;
53	import com.sun.tools.javac.code.Symbol;	52	import com.sun.tools.javac.code.Symbol;
54	import com.sun.tools.javac.code.Symbol.ClassSymbol;	53	import com.sun.tools.javac.code.Symbol.ClassSymbol;
55	import com.sun.tools.javac.code.Symbol.MethodSymbol;	54	import com.sun.tools.javac.code.Symbol.MethodSymbol;
56	import com.sun.tools.javac.code.Symbol.TypeSymbol;	55	import com.sun.tools.javac.code.Symbol.TypeSymbol;
57	import com.sun.tools.javac.code.Type;	56	import com.sun.tools.javac.code.Type;
58	import com.sun.tools.javac.code.TypeTags;	57	import com.sun.tools.javac.code.TypeTag;
59	import com.sun.tools.javac.model.JavacTypes;	58	import com.sun.tools.javac.model.JavacTypes;
60	import com.sun.tools.javac.util.Context;	59	import com.sun.tools.javac.util.Context;
61	import javax.lang.model.element.*;	60	import javax.lang.model.element.*;
Lines 121-127 Link Here
121	if ((m.flags() & Flags.STATIC) == 0) {	120	if ((m.flags() & Flags.STATIC) == 0) {
122	ClassSymbol owner = (ClassSymbol) m.owner;	121	ClassSymbol owner = (ClassSymbol) m.owner;
123	for (Type sup = jctypes.supertype(m.owner.type);	122	for (Type sup = jctypes.supertype(m.owner.type);
124	sup.tag == TypeTags.CLASS;	123	sup.hasTag(TypeTag.CLASS);
125	sup = jctypes.supertype(sup)) {	124	sup = jctypes.supertype(sup)) {
126	for (Scope.Entry e = sup.tsym.members().lookup(m.name);	125	for (Scope.Entry e = sup.tsym.members().lookup(m.name);
127	e.scope != null; e = e.next()) {	126	e.scope != null; e = e.next()) {
Lines 176-182 Link Here
176	// Check if this method overrides a deprecated method.	175	// Check if this method overrides a deprecated method.
177	TypeSymbol owner = sym.enclClass();	176	TypeSymbol owner = sym.enclClass();
178	for (Type sup = jctypes.supertype(owner.type);	177	for (Type sup = jctypes.supertype(owner.type);
179	sup.tag == TypeTags.CLASS;	178	sup.hasTag(TypeTag.CLASS);
180	sup = jctypes.supertype(sup)) {	179	sup = jctypes.supertype(sup)) {
181	for (Scope.Entry e = sup.tsym.members().lookup(sym.name);	180	for (Scope.Entry e = sup.tsym.members().lookup(sym.name);
182	e.scope != null; e = e.next()) {	181	e.scope != null; e = e.next()) {
Lines 210-216 Link Here
210	public ExecutableElement getOverriddenMethod(ExecutableElement method) {	209	public ExecutableElement getOverriddenMethod(ExecutableElement method) {
211	MethodSymbol m = (MethodSymbol)method;	210	MethodSymbol m = (MethodSymbol)method;
212	ClassSymbol origin = (ClassSymbol)m.owner;	211	ClassSymbol origin = (ClassSymbol)m.owner;
213	for (Type t = jctypes.supertype(origin.type); t.tag == TypeTags.CLASS; t = jctypes.supertype(t)) {	212	for (Type t = jctypes.supertype(origin.type); t.hasTag(TypeTag.CLASS); t = jctypes.supertype(t)) {
214	TypeSymbol c = t.tsym;	213	TypeSymbol c = t.tsym;
215	Scope.Entry e = c.members().lookup(m.name);	214	Scope.Entry e = c.members().lookup(m.name);
216	while (e.scope != null) {	215	while (e.scope != null) {

Lines 51-57 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/pretty/WidthEstimator.java (-4 / +3 lines)
51	import com.sun.tools.javac.tree.TreeInfo;	51	import com.sun.tools.javac.tree.TreeInfo;
52		52
53	import static com.sun.tools.javac.code.Flags.*;	53	import static com.sun.tools.javac.code.Flags.*;
54	import static com.sun.tools.javac.code.TypeTags.*;
55		54
56	/** Estimate the printed width of a tree	55	/** Estimate the printed width of a tree
57	*/	56	*/
Lines 175-181 Link Here
175	if (tree.elemtype != null) {	174	if (tree.elemtype != null) {
176	width+=4;	175	width+=4;
177	JCTree elemtype = tree.elemtype;	176	JCTree elemtype = tree.elemtype;
178	while (elemtype.getTag() == JCTree.TYPEARRAY) {	177	while (elemtype.getTag() == JCTree.Tag.TYPEARRAY) {
179	width+=2;	178	width+=2;
180	elemtype = ((JCArrayTypeTree) elemtype).elemtype;	179	elemtype = ((JCArrayTypeTree) elemtype).elemtype;
181	}	180	}
Lines 232-238 Link Here
232	public void visitAssignop(JCAssignOp tree) {	231	public void visitAssignop(JCAssignOp tree) {
233	open(prec, TreeInfo.assignopPrec);	232	open(prec, TreeInfo.assignopPrec);
234	width+=3;	233	width+=3;
235	width(treeinfo.operatorName(tree.getTag() - JCTree.ASGOffset));	234	width(treeinfo.operatorName(tree.getTag()));
236	width(tree.lhs, TreeInfo.assignopPrec + 1);	235	width(tree.lhs, TreeInfo.assignopPrec + 1);
237	width(tree.rhs, TreeInfo.assignopPrec);	236	width(tree.rhs, TreeInfo.assignopPrec);
238	}	237	}
Lines 320-326 Link Here
320	}	319	}
321		320
322	public void visitTypeIdent(JCPrimitiveTypeTree tree) {	321	public void visitTypeIdent(JCPrimitiveTypeTree tree) {
323	width(symbols.typeOfTag[tree.typetag].tsym.name);	322	width(tree.typetag.name().toLowerCase());
324	}	323	}
325		324
326	public void visitTypeArray(JCArrayTypeTree tree) {	325	public void visitTypeArray(JCArrayTypeTree tree) {