import com.sun.source.tree.Tree;

import java.util.Map;

import java.util.concurrent.Callable;

import org.netbeans.spi.whitelist.support.WhiteListIndex;

import org.netbeans.spi.whitelist.support.WhiteListIndex;

import org.netbeans.spi.whitelist.support.WhiteListIndexEvent;

import org.netbeans.spi.whitelist.support.WhiteListIndexListener;

    private void refresh(final @NonNull URL root) {

        assert root != null;

        final FileObject rootFo = URLMapper.findFileObject(root);

        final Set<FileObject> files;

        final Callback callback;

        synchronized (this) {

            files = currentFiles;

            callback = currentCallback;

        }

        if (rootFo != null &&

            files != null &&

            files.contains(rootFo)) {

            assert callback != null;

            enqueue(new Work(rootFo, currentCallback));

        }

    }

        final Set<FileObject> filesWithErrors = getFilesWithAttachedErrors(root);

        if (tasks.isEmpty()) {

            filesWithErrors.remove(file);

        } else {

            filesWithErrors.add(file);

        }

        LOG.log(Level.FINE, "setting {1} for {0}", new Object[]{file, tasks});

        callback.setTasks(file, tasks);

                <friend>org.netbeans.modules.whitelist</friend>

                <friend>org.netbeans.modules.whitelist</friend>

        <change id="WhiteListIndex">

            <api name="whitelist"/>

            <summary>Added WhiteListQuery to check violations of runtime restrictions</summary>

            <version major="1" minor="2"/>

            <date day="14" month="9" year="2011"/>

            <author login="tzezula"/>

            <compatibility addition="yes" modification="no" semantic="compatible" source="compatible" binary="compatible"/>

            <description>

                <p>

                    Added WhiteListIndex to provide persistent index of the white list violations.

                </p>

            </description>

            <class package="org.netbeans.api.whitelist.support" name="WhiteListIndex"/>

            <class package="org.netbeans.spi.whitelist.support" name="WhiteListIndexListener"/>

            <class package="org.netbeans.spi.whitelist.support" name="WhiteListIndexEvent"/>

            <issue number="202063"/>

        </change>

                    <code-name-base>org.netbeans.api.java.classpath</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.30</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.23</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.java.preprocessorbridge</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <specification-version>1.22</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.parsing.api</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.43</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

                    <code-name-base>org.netbeans.modules.parsing.lucene</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>2</release-version>

                        <specification-version>2.3</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2011 Sun Microsystems, Inc.

 */

package org.netbeans.modules.whitelist.index;

import java.net.URL;

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.api.whitelist.WhiteListQuery;

import org.netbeans.spi.whitelist.support.WhiteListIndex;

import org.openide.filesystems.FileObject;

import org.openide.util.Exceptions;

import org.openide.util.Parameters;

/**

 *

 * @author Tomas Zezula

 */

public abstract class WhiteListIndexAccessor {

    private static volatile WhiteListIndexAccessor instance;

    @NonNull

    public static synchronized WhiteListIndexAccessor getInstance() {

        if (instance == null) {

            try {

                Class.forName(WhiteListIndex.class.getName(), true, WhiteListIndexAccessor.class.getClassLoader());

                assert instance != null;

            } catch (ClassNotFoundException ex) {

                Exceptions.printStackTrace(ex);

            }

        }

        return instance;

    }

    public static void setInstance(@NonNull final WhiteListIndexAccessor _instance) {

        Parameters.notNull("_instance", _instance); //NOI18N

        instance = _instance;

    }

    public abstract void refresh(@NonNull URL root);

    public abstract WhiteListIndex.Problem createProblem(

            @NonNull WhiteListQuery.Result result,

            @NonNull FileObject root,

            @NonNull String key,

            int line);

}

import com.sun.source.tree.Tree;

import org.netbeans.api.annotations.common.NullAllowed;

import org.netbeans.modules.parsing.lucene.support.Index;

import org.netbeans.modules.parsing.lucene.support.Queries.QueryKind;

import org.netbeans.spi.whitelist.support.WhiteListIndex;

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2011 Sun Microsystems, Inc.

 */

package org.netbeans.spi.whitelist.support;

import com.sun.source.tree.ClassTree;

import com.sun.source.tree.CompilationUnitTree;

import com.sun.source.tree.IdentifierTree;

import com.sun.source.tree.MemberSelectTree;

import com.sun.source.tree.MethodInvocationTree;

import com.sun.source.tree.MethodTree;

import com.sun.source.tree.NewClassTree;

import com.sun.source.tree.Tree;

import com.sun.source.util.TreePathScanner;

import com.sun.source.util.Trees;

import java.net.URL;

import java.util.ArrayDeque;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Callable;

import java.util.concurrent.CopyOnWriteArrayList;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import org.netbeans.api.annotations.common.CheckForNull;

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.api.annotations.common.NullAllowed;

import org.netbeans.api.java.source.ElementHandle;

import org.netbeans.api.whitelist.WhiteListQuery;

import org.netbeans.api.whitelist.WhiteListQuery.Result;

import org.netbeans.api.whitelist.WhiteListQuery.WhiteList;

import org.netbeans.modules.whitelist.index.WhiteListIndexAccessor;

import org.netbeans.modules.whitelist.index.WhiteListIndexerPlugin;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.util.Exceptions;

import org.openide.util.Parameters;

/**

 * A persistent index of white list violations.

 * @author Tomas Zezula

 * @since 1.2

 */

public final class WhiteListIndex {

    static {

        WhiteListIndexAccessor.setInstance(new WhiteListIndexAccessorImpl());

    }

    private static WhiteListIndex instance;

    private final List<WhiteListIndexListener> listeners = new CopyOnWriteArrayList<WhiteListIndexListener>();

    private WhiteListIndex() {}

    /**

     * Returns the white list violations for given root or file.

     * @param root the root to get white list violations for

     * @param file the file to restrict the white list violation search or null

     * @return a {@link Collection} of {@link Problem}s

     * @throws IllegalArgumentException in case when file is not under the root or it's not a valid file

     * @throws UnsupportedOperationException when the index is not supported by the IDE

     */

    @NonNull

    public Collection<? extends Problem> getWhiteListViolations(

            @NonNull final FileObject root,

            @NullAllowed final FileObject file) throws IllegalArgumentException, UnsupportedOperationException {

        Parameters.notNull("scope", root); //NOI18N

        if (file != null && !(root.equals(file) || FileUtil.isParentOf(root, file))) {

            throw new IllegalArgumentException(

                    "The file: " + //NOI18N

                    FileUtil.getFileDisplayName(file) +

                    " has to be inside the root: " + //NOI18N

                    FileUtil.getFileDisplayName(root));

        }

        if (file != null && !file.isData()) {

            throw new IllegalArgumentException(

                    "The file: " + //NOI18N

                    FileUtil.getFileDisplayName(file) +

                    " has to be file.");    //NOI18N

        }

        return WhiteListIndexerPlugin.getWhiteListViolations(root,file);

    }

    /**

     * Adds {@link WhiteListIndexListener}.

     * The listener is notified when the white list index is changed.

     * @param listener the listener to be added

     */

    public void addWhiteListIndexListener(@NonNull final WhiteListIndexListener listener) {

        Parameters.notNull("listener", listener);   //NOI18N

        listeners.add(listener);

    }

    /**

     * Removes {@link WhiteListIndexListener}.

     * @param listener the listener to be removed

     */

    public void removeWhiteListIndexListener(@NonNull final WhiteListIndexListener listener) {

        Parameters.notNull("listener", listener);   //NOI18N

        listeners.remove(listener);

    }

    /**

     * Utility method to check the given {@link CompilationUnitTree} for white list violations.

     * @param unit the {@link CompilationUnitTree} to be analyzed

     * @param whitelist the {@link WhiteList} to use to check the violations

     * @param trees the {@link Trees} service

     * @param cancel the cancel request. If the {@link Callable} returns true the check is canceled

     * and null is returned.

     * @return a {@link Map} of {@link Tree}s with attached white list violations or null when the

     * scan was canceled.

     */

    @CheckForNull

    public static Map<? extends Tree, ? extends WhiteListQuery.Result> getWhiteListViolations(

            @NonNull final CompilationUnitTree unit,

            @NonNull final WhiteListQuery.WhiteList whitelist,

            @NonNull final Trees trees,

            @NullAllowed final Callable<Boolean> cancel) {

        Parameters.notNull("tree", unit);           //NOI18N

        Parameters.notNull("whitelist", whitelist); //NOI18N

        Parameters.notNull("trees", trees);         //NOI18N

        final Map<Tree,WhiteListQuery.Result> result = new HashMap<Tree, Result>();

        final WhiteListScanner scanner = new WhiteListScanner(trees, whitelist, cancel);

        try {

            scanner.scan(unit, result);

            return result;

        } catch (WhiteListScanner.Cancel ce) {

            return null;

        }

    }

    /**

     * Returns an instance of {@link WhiteListIndex}

     * @return the instance of {@link WhiteListIndex}

     */

    public static synchronized WhiteListIndex getDefault() {

        if (instance == null) {

            instance = new WhiteListIndex();

        }

        return instance;

    }

    /**

     * Represent a white list violation

     */

    public static final class Problem {

        private final WhiteListQuery.Result result;

        private final FileObject root;

        private final String relPath;

        private final int line;

        private Problem (

                @NonNull final WhiteListQuery.Result result,

                @NonNull final FileObject root,

                @NonNull final String relPath,

                final int line) {

            Parameters.notNull("result", result);   //NOI18N

            Parameters.notNull("root", root);   //NOI18N

            Parameters.notNull("relPath", relPath); //NOI18N

            this.result = result;

            this.root = root;

            this.relPath = relPath;

            this.line = line;

        }

        /**

         * Returns {@link WhiteListQuery.Result} describing the

         * white list violation.

         * @return the {@link WhiteListQuery.Result}

         */

        @NonNull

        public WhiteListQuery.Result getResult() {

            return result;

        }

        /**

         * Returns the file in which the white list violation occured.

         * @return the {@link FileObject}

         */

        @CheckForNull

        public FileObject getFile() {

            return root.getFileObject(relPath);

        }

        /**

         * Returns the line number of white list violation.

         * @return the line number

         */

        public int getLine() {

            return line;

        }

    }

    //<editor-fold defaultstate="collapsed" desc="Private implementation">

    private void fireIndexChange(final URL root) {

        final WhiteListIndexEvent event = new WhiteListIndexEvent(this, root);

        for (WhiteListIndexListener l : listeners) {

            l.indexChanged(event);

        }

    }

    private static final class WhiteListIndexAccessorImpl extends WhiteListIndexAccessor {

        @Override

        public void refresh(@NonNull URL root) {

            WhiteListIndex.getDefault().fireIndexChange(root);

        }

        @Override

        @NonNull

        public Problem createProblem(

                @NonNull final Result result,

                @NonNull final FileObject root,

                @NonNull final String key,

                int line) {

            return new Problem(result, root, key, line);

        }

    }

    private static class WhiteListScanner extends TreePathScanner<Void, Map<Tree,WhiteListQuery.Result>> {

        private final Trees trees;

        private final Callable<Boolean> cancel;

        private final WhiteList whiteList;

        private final ArrayDeque<MethodInvocationTree> methodInvocation;

        WhiteListScanner(

            final Trees trees,

            final WhiteList whiteList,

            final Callable<Boolean> cancel) {

            this.trees = trees;

            this.whiteList = whiteList;

            this.cancel = cancel;

            methodInvocation = new ArrayDeque<MethodInvocationTree>();

        }

        @Override

        public Void visitMethod(MethodTree node, Map<Tree,WhiteListQuery.Result> p) {

            checkCancel();

            return super.visitMethod(node, p);

        }

        @Override

        public Void visitClass(ClassTree node, Map<Tree,WhiteListQuery.Result> p) {

            checkCancel();

            return super.visitClass(node, p);

        }

        @Override

        public Void visitIdentifier(IdentifierTree node, Map<Tree,WhiteListQuery.Result> p) {

            handleNode(node,p);

            return super.visitIdentifier(node, p);

        }

        @Override

        public Void visitMemberSelect(MemberSelectTree node, Map<Tree,WhiteListQuery.Result> p) {

            handleNode(node,p);

            return super.visitMemberSelect(node, p);

        }

        @Override

        public Void visitNewClass(NewClassTree node, Map<Tree,WhiteListQuery.Result> p) {

            final Element e = trees.getElement(getCurrentPath());

            final WhiteListQuery.Result res;

            if (e != null && !(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {

                p.put(node,res);

            }

            scan(node.getTypeArguments(), p);

            scan(node.getArguments(), p);

            scan(node.getClassBody(), p);

            return null;

        }

        @Override

        public Void visitMethodInvocation(MethodInvocationTree node, Map<Tree,WhiteListQuery.Result> p) {

            methodInvocation.offerFirst(node);

            super.visitMethodInvocation(node, p);

            methodInvocation.removeFirst();

            return null;

        }

        private void handleNode(

                final Tree node,

                final Map<Tree,WhiteListQuery.Result> p) {

            final Element e = trees.getElement(getCurrentPath());

            if (e == null) {

                return;

            }

            final ElementKind k = e.getKind();

            Tree toReport =  null;

            if (k.isClass() || k.isInterface()) {

                toReport=node;

            } else if ((k == ElementKind.METHOD || k == ElementKind.CONSTRUCTOR) &&

                    !methodInvocation.isEmpty()) {

                toReport=methodInvocation.peekFirst();

            }

            final WhiteListQuery.Result res;

            if (toReport != null &&

                !(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {

                    p.put(toReport,res);

            }

        }

        private void checkCancel() {

            try {

                if (cancel != null && cancel.call() == Boolean.TRUE) {

                    throw new Cancel();

                }

            } catch (Exception ex) {

                Exceptions.printStackTrace(ex);

            }

        }

        static final class Cancel extends RuntimeException {

        }

    }

    //</editor-fold>

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2011 Sun Microsystems, Inc.

 */

package org.netbeans.spi.whitelist.support;

import java.net.URL;

import java.util.EventObject;

import org.netbeans.api.annotations.common.NonNull;

import org.openide.util.Parameters;

/**

 * WhiteListIndexEvent is used to notify interested parties about

 * changes in persistent index of white list violations.

 * @author Tomas Zezula

 * @since 1.2

 */

public class WhiteListIndexEvent extends EventObject {

    private final URL root;

    WhiteListIndexEvent(@NonNull final Object source, @NonNull final URL root) {

        super(source);

        Parameters.notNull("root", root);   //NOI18N

        this.root = root;

    }

    /**

     * Returns a source root for which the index was changed.

     * @return the {@link URL} of the source root.

     */

    @NonNull

    public URL getRoot() {

        return root;

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2011 Sun Microsystems, Inc.

 */

package org.netbeans.spi.whitelist.support;

import java.util.EventListener;

import org.netbeans.api.annotations.common.NonNull;

/**

 * The listener interface for receiving {@link WhiteListIndex} events.

 * @author Tomas Zezula

 * @since 1.2

 */

public interface WhiteListIndexListener extends EventListener {

    /**

     * Invoked when the index for a source root changed

     * @param event the event providing the change details

     */

    void indexChanged (@NonNull WhiteListIndexEvent event);

}