1 /*

     2  * Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.

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

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

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

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package com.sun.tools.jdeps;

    26 

    27 import java.io.PrintStream;

    28 import java.util.Comparator;

    29 import java.util.HashMap;

    30 import java.util.HashSet;

    31 import java.util.List;

    32 import java.util.Map;

    33 import java.util.Objects;

    34 import java.util.Set;

    35 import java.util.stream.Collectors;

    36 import java.util.stream.Stream;

    37 

    38 import com.sun.tools.classfile.Dependency.Location;

    39 

    40 /**

    41  * Dependency Analyzer.

    42  */

    43 public class Analyzer {

    44     /**

    45      * Type of the dependency analysis.  Appropriate level of data

    46      * will be stored.

    47      */

    48     public enum Type {

    49         SUMMARY,

    50         PACKAGE,

    51         CLASS,

    52         VERBOSE

    53     }

    54 

    55     /**

    56      * Filter to be applied when analyzing the dependencies from the given archives.

    57      * Only the accepted dependencies are recorded.

    58      */

    59     interface Filter {

    60         boolean accepts(Location origin, Archive originArchive, Location target, Archive targetArchive);

    61     }

    62 

    63     protected final Type type;

    64     protected final Filter filter;

    65     protected final Map<Archive, ArchiveDeps> results = new HashMap<>();

    66     protected final Map<Location, Archive> map = new HashMap<>();

    67     private static final Archive NOT_FOUND

    68         = new Archive(JdepsTask.getMessage("artifact.not.found"));

    69 

    70     /**

    71      * Constructs an Analyzer instance.

    72      *

    73      * @param type Type of the dependency analysis

    74      * @param filter

    75      */

    76     public Analyzer(Type type, Filter filter) {

    77         this.type = type;

    78         this.filter = filter;

    79     }

    80 

    81     /**

    82      * Performs the dependency analysis on the given archives.

    83      */

    84     public boolean run(List<Archive> archives) {

    85         // build a map from Location to Archive

    86         buildLocationArchiveMap(archives);

    87 

    88         // traverse and analyze all dependencies

    89         for (Archive archive : archives) {

    90             ArchiveDeps deps = new ArchiveDeps(archive, type);

    91             archive.visitDependences(deps);

    92             results.put(archive, deps);

    93         }

    94         return true;

    95     }

    96 

    97     protected void buildLocationArchiveMap(List<Archive> archives) {

    98         // build a map from Location to Archive

    99         for (Archive archive: archives) {

   100             for (Location l: archive.getClasses()) {

   101                 if (!map.containsKey(l)) {

   102                     map.put(l, archive);

   103                 } else {

   104                     // duplicated class warning?

   105                 }

   106             }

   107         }

   108     }

   109 

   110     public boolean hasDependences(Archive archive) {

   111         if (results.containsKey(archive)) {

   112             return results.get(archive).dependencies().size() > 0;

   113         }

   114         return false;

   115     }

   116 

   117     public Set<String> dependences(Archive source) {

   118         ArchiveDeps result = results.get(source);

   119         return result.dependencies().stream()

   120                      .map(Dep::target)

   121                      .collect(Collectors.toSet());

   122     }

   123 

   124     public interface Visitor {

   125         /**

   126          * Visits a recorded dependency from origin to target which can be

   127          * a fully-qualified classname, a package name, a module or

   128          * archive name depending on the Analyzer's type.

   129          */

   130         public void visitDependence(String origin, Archive originArchive,

   131                                     String target, Archive targetArchive);

   132     }

   133 

   134     /**

   135      * Visit the dependencies of the given source.

   136      * If the requested level is SUMMARY, it will visit the required archives list.

   137      */

   138     public void visitDependences(Archive source, Visitor v, Type level) {

   139         if (level == Type.SUMMARY) {

   140             final ArchiveDeps result = results.get(source);

   141             final Set<Archive> reqs = result.requires();

   142             Stream<Archive> stream = reqs.stream();

   143             if (reqs.isEmpty()) {

   144                 if (hasDependences(source)) {

   145                     // If reqs.isEmpty() and we have dependences, then it means

   146                     // that the dependences are from 'source' onto itself.

   147                     stream = Stream.of(source);

   148                 }

   149             }

   150             stream.sorted(Comparator.comparing(Archive::getName))

   151                   .forEach(archive -> {

   152                       Profile profile = result.getTargetProfile(archive);

   153                       v.visitDependence(source.getName(), source,

   154                                         profile != null ? profile.profileName() : archive.getName(), archive);

   155                   });

   156         } else {

   157             ArchiveDeps result = results.get(source);

   158             if (level != type) {

   159                 // requesting different level of analysis

   160                 result = new ArchiveDeps(source, level);

   161                 source.visitDependences(result);

   162             }

   163             result.dependencies().stream()

   164                   .sorted(Comparator.comparing(Dep::origin)

   165                                     .thenComparing(Dep::target))

   166                   .forEach(d -> v.visitDependence(d.origin(), d.originArchive(), d.target(), d.targetArchive()));

   167         }

   168     }

   169 

   170     public void visitDependences(Archive source, Visitor v) {

   171         visitDependences(source, v, type);

   172     }

   173 

   174     /**

   175      * ArchiveDeps contains the dependencies for an Archive that can have one or

   176      * more classes.

   177      */

   178     class ArchiveDeps implements Archive.Visitor {

   179         protected final Archive archive;

   180         protected final Set<Archive> requires;

   181         protected final Set<Dep> deps;

   182         protected final Type level;

   183         private Profile profile;

   184         ArchiveDeps(Archive archive, Type level) {

   185             this.archive = archive;

   186             this.deps = new HashSet<>();

   187             this.requires = new HashSet<>();

   188             this.level = level;

   189         }

   190 

   191         Set<Dep> dependencies() {

   192             return deps;

   193         }

   194 

   195         Set<Archive> requires() {

   196             return requires;

   197         }

   198 

   199         Profile getTargetProfile(Archive target) {

   200             if (target instanceof Module) {

   201                 return Profile.getProfile((Module) target);

   202             } else {

   203                 return null;

   204             }

   205         }

   206 

   207         Archive findArchive(Location t) {

   208             Archive target = archive.getClasses().contains(t) ? archive : map.get(t);

   209             if (target == null) {

   210                 map.put(t, target = NOT_FOUND);

   211             }

   212             return target;

   213         }

   214 

   215         // return classname or package name depedning on the level

   216         private String getLocationName(Location o) {

   217             if (level == Type.CLASS || level == Type.VERBOSE) {

   218                 return o.getClassName();

   219             } else {

   220                 String pkg = o.getPackageName();

   221                 return pkg.isEmpty() ? "<unnamed>" : pkg;

   222             }

   223         }

   224 

   225         @Override

   226         public void visit(Location o, Location t) {

   227             Archive targetArchive = findArchive(t);

   228             if (filter.accepts(o, archive, t, targetArchive)) {

   229                 addDep(o, t);

   230                 if (archive != targetArchive && !requires.contains(targetArchive)) {

   231                     requires.add(targetArchive);

   232                 }

   233             }

   234             if (targetArchive instanceof Module) {

   235                 Profile p = Profile.getProfile(t.getPackageName());

   236                 if (profile == null || (p != null && p.compareTo(profile) > 0)) {

   237                     profile = p;

   238                 }

   239             }

   240         }

   241 

   242         private Dep curDep;

   243         protected Dep addDep(Location o, Location t) {

   244             String origin = getLocationName(o);

   245             String target = getLocationName(t);

   246             Archive targetArchive = findArchive(t);

   247             if (curDep != null &&

   248                     curDep.origin().equals(origin) &&

   249                     curDep.originArchive() == archive &&

   250                     curDep.target().equals(target) &&

   251                     curDep.targetArchive() == targetArchive) {

   252                 return curDep;

   253             }

   254 

   255             Dep e = new Dep(origin, archive, target, targetArchive);

   256             if (deps.contains(e)) {

   257                 for (Dep e1 : deps) {

   258                     if (e.equals(e1)) {

   259                         curDep = e1;

   260                     }

   261                 }

   262             } else {

   263                 deps.add(e);

   264                 curDep = e;

   265             }

   266             return curDep;

   267         }

   268     }

   269 

   270     /*

   271      * Class-level or package-level dependency

   272      */

   273     class Dep {

   274         final String origin;

   275         final Archive originArchive;

   276         final String target;

   277         final Archive targetArchive;

   278 

   279         Dep(String origin, Archive originArchive, String target, Archive targetArchive) {

   280             this.origin = origin;

   281             this.originArchive = originArchive;

   282             this.target = target;

   283             this.targetArchive = targetArchive;

   284         }

   285 

   286         String origin() {

   287             return origin;

   288         }

   289 

   290         Archive originArchive() {

   291             return originArchive;

   292         }

   293 

   294         String target() {

   295             return target;

   296         }

   297 

   298         Archive targetArchive() {

   299             return targetArchive;

   300         }

   301 

   302         @Override

   303         @SuppressWarnings("unchecked")

   304         public boolean equals(Object o) {

   305             if (o instanceof Dep) {

   306                 Dep d = (Dep) o;

   307                 return this.origin.equals(d.origin) &&

   308                         this.originArchive == d.originArchive &&

   309                         this.target.equals(d.target) &&

   310                         this.targetArchive == d.targetArchive;

   311             }

   312             return false;

   313         }

   314 

   315         @Override

   316         public int hashCode() {

   317             int hash = 7;

   318             hash = 67*hash + Objects.hashCode(this.origin)

   319                            + Objects.hashCode(this.originArchive)

   320                            + Objects.hashCode(this.target)

   321                            + Objects.hashCode(this.targetArchive);

   322             return hash;

   323         }

   324 

   325         public String toString() {

   326             return String.format("%s (%s) -> %s (%s)%n",

   327                     origin, originArchive.getName(),

   328                     target, targetArchive.getName());

   329         }

   330     }

   331 

   332     static Analyzer getExportedAPIsAnalyzer() {

   333         return new ModuleAccessAnalyzer(ModuleAccessAnalyzer.reexportsFilter, true);

   334     }

   335 

   336     static Analyzer getModuleAccessAnalyzer() {

   337         return new ModuleAccessAnalyzer(ModuleAccessAnalyzer.accessCheckFilter, false);

   338     }

   339 

   340     private static class ModuleAccessAnalyzer extends Analyzer {

   341         private final boolean apionly;

   342         ModuleAccessAnalyzer(Filter filter, boolean apionly) {

   343             super(Type.VERBOSE, filter);

   344             this.apionly = apionly;

   345         }

   346         /**

   347          * Verify module access

   348          */

   349         public boolean run(List<Archive> archives) {

   350             // build a map from Location to Archive

   351             buildLocationArchiveMap(archives);

   352 

   353             // traverse and analyze all dependencies

   354             int count = 0;

   355             for (Archive archive : archives) {

   356                 ArchiveDeps checker = new ArchiveDeps(archive, type);

   357                 archive.visitDependences(checker);

   358                 count += checker.dependencies().size();

   359                 // output if any error

   360                 Module m = (Module)archive;

   361                 printDependences(System.err, m, checker.dependencies());

   362                 results.put(archive, checker);

   363             }

   364             return count == 0;

   365         }

   366 

   367         private void printDependences(PrintStream out, Module m, Set<Dep> deps) {

   368             if (deps.isEmpty())

   369                 return;

   370 

   371             String msg = apionly ? "API reference:" : "inaccessible reference:";

   372             deps.stream().sorted(Comparator.comparing(Dep::origin)

   373                                            .thenComparing(Dep::target))

   374                 .forEach(d -> out.format("%s %s (%s) -> %s (%s)%n", msg,

   375                                          d.origin(), d.originArchive().getName(),

   376                                          d.target(), d.targetArchive().getName()));

   377             if (apionly) {

   378                 out.format("Dependences missing re-exports=\"true\" attribute:%n");

   379                 deps.stream()

   380                         .map(Dep::targetArchive)

   381                         .map(Archive::getName)

   382                         .distinct()

   383                         .sorted()

   384                         .forEach(d -> out.format("  %s -> %s%n", m.name(), d));

   385             }

   386         }

   387 

   388         private static Module findModule(Archive archive) {

   389             if (Module.class.isInstance(archive)) {

   390                 return (Module) archive;

   391             } else {

   392                 return null;

   393             }

   394         }

   395 

   396         // returns true if target is accessible by origin

   397         private static boolean canAccess(Location o, Archive originArchive, Location t, Archive targetArchive) {

   398             Module origin = findModule(originArchive);

   399             Module target = findModule(targetArchive);

   400 

   401             if (targetArchive == Analyzer.NOT_FOUND) {

   402                 return false;

   403             }

   404 

   405             // unnamed module

   406             // ## should check public type?

   407             if (target == null)

   408                 return true;

   409 

   410             // module-private

   411             if (origin == target)

   412                 return true;

   413 

   414             return target.isAccessibleTo(t.getClassName(), origin);

   415         }

   416 

   417         static final Filter accessCheckFilter = new Filter() {

   418             @Override

   419             public boolean accepts(Location o, Archive originArchive, Location t, Archive targetArchive) {

   420                 return !canAccess(o, originArchive, t, targetArchive);

   421             }

   422         };

   423 

   424         static final Filter reexportsFilter = new Filter() {

   425             @Override

   426             public boolean accepts(Location o, Archive originArchive, Location t, Archive targetArchive) {

   427                 Module origin = findModule(originArchive);

   428                 Module target = findModule(targetArchive);

   429                 if (!origin.isExportedPackage(o.getPackageName())) {

   430                     // filter non-exported classes

   431                     return false;

   432                 }

   433 

   434                 boolean accessible = canAccess(o, originArchive, t, targetArchive);

   435                 if (!accessible)

   436                     return true;

   437 

   438                 String mn = target.name();

   439                 // skip checking re-exports for java.base

   440                 if (origin == target || "java.base".equals(mn))

   441                     return false;

   442 

   443                 assert origin.requires().containsKey(mn);  // otherwise, should not be accessible

   444                 if (origin.requires().get(mn)) {

   445                     return false;

   446                 }

   447                 return true;

   448             }

   449         };

   450     }

   451 }