Java tutorial
/* * Copyright 2014-present Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may * not use this file except in compliance with the License. You may obtain * a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package com.facebook.buck.tools.dxanalysis; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.FieldNode; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import javax.annotation.Nullable; public class MutabilityAnalyzer { /** * Deeply immutable "sorts" of types. See {@link org.objectweb.asm.Type#getSort()}. */ static final ImmutableSet<Integer> IMMUTABLE_TYPE_SORTS = ImmutableSet.of(Type.BOOLEAN, Type.BYTE, Type.CHAR, Type.DOUBLE, Type.FLOAT, Type.INT, Type.LONG, Type.SHORT); /** * External classes that are final and deeply immutable. */ private static final ImmutableSet<String> EXTERNAL_IMMUTABLE_CLASSES = ImmutableSet.of("java/lang/String", "java/lang/Integer"); /** * NonExternal classes that are non-final but have no inherent mutability. */ public static final ImmutableSet<String> EXTERNAL_IMMUTABLE_BASE_CLASSES = ImmutableSet.of("java/lang/Object", "java/lang/Enum"); /** * All classes under analysis. */ private final ImmutableMap<String, ClassNode> allClasses; /** * Any class that is definitely mutable. All subclasses become mutable as well. * Superclasses are marked has having mutable descendents. */ private final Set<String> trulyMutableClasses; /** * Classes that have truly mutable descendents. Having a field of one of these types * makes you truly mutable, but extending one does not. */ private final Set<String> classesWithMutableDescendents; /** * Only set once in go(). */ @Nullable private ImmutableSet<String> immutableClasses; /** * True iff we made progress during this round. */ private boolean madeProgress; /** * Log of messages. */ private List<String> log = new ArrayList<>(); public static MutabilityAnalyzer analyze(ImmutableMap<String, ClassNode> allClasses) { MutabilityAnalyzer analyzer = new MutabilityAnalyzer(allClasses); analyzer.go(); return analyzer; } private MutabilityAnalyzer(ImmutableMap<String, ClassNode> allClasses) { this.allClasses = allClasses; trulyMutableClasses = new HashSet<>(); classesWithMutableDescendents = new HashSet<>(); } public ImmutableList<String> getLog() { return ImmutableList.copyOf(log); } public ImmutableSet<String> getImmutableClasses() { return immutableClasses; } public boolean isTypeImmutable(String desc) { Type type = Type.getType(desc); if (IMMUTABLE_TYPE_SORTS.contains(type.getSort())) { return true; } if (type.getSort() != Type.OBJECT) { return false; } if (Sets.union(EXTERNAL_IMMUTABLE_CLASSES, immutableClasses).contains(type.getInternalName())) { return true; } return false; } private void go() { while (true) { madeProgress = false; for (ClassNode klass : allClasses.values()) { analyzeClass(klass); } if (!madeProgress) { break; } } immutableClasses = ImmutableSet.copyOf(Sets.difference(allClasses.keySet(), Sets.union(trulyMutableClasses, classesWithMutableDescendents))); } private void markClassTrulyMutable(String className) { if (trulyMutableClasses.contains(className)) { return; } if (!allClasses.containsKey(className)) { throw new RuntimeException("Tried to mark external class '" + className + "' truly mutable"); } trulyMutableClasses.add(className); madeProgress = true; markClassAsHavingMutableDescendents(className); } private void markClassAsHavingMutableDescendents(String className) { if (classesWithMutableDescendents.contains(className)) { return; } ClassNode klass = allClasses.get(className); if (klass == null) { return; } classesWithMutableDescendents.add(className); madeProgress = true; markClassAsHavingMutableDescendents(klass.superName); for (String iface : klass.interfaces) { markClassAsHavingMutableDescendents(iface); } } private boolean superClassIsDefinitelyMutable(String superClassName) { if (trulyMutableClasses.contains(superClassName)) { return true; } if (EXTERNAL_IMMUTABLE_BASE_CLASSES.contains(superClassName)) { return false; } if (!allClasses.containsKey(superClassName)) { // All external classes are assumed to be mutable unless whitelisted. return true; } // Assume internal classes are immutable until proven otherwise (in later rounds). return false; } private boolean classIsDefinitelyMutable(ClassNode klass) { if (superClassIsDefinitelyMutable(klass.superName)) { log.add("Mutable parent: " + klass.name + " < " + klass.superName); return true; } for (FieldNode field : klass.fields) { if ((field.access & Opcodes.ACC_STATIC) != 0) { continue; } if ((field.access & Opcodes.ACC_FINAL) == 0) { log.add("Non-final field: " + klass.name + "#" + field.name + ":" + field.desc); return true; } if (field.name.contains("$")) { // Generated fields are assumed to be effectively immutable. // This could, in principle, miss an issue like a static reference to a // seemingly-immutable inner class object that maintains a hidden reference // to its mutable outer object, but that seems unlikely. continue; } Type type = Type.getType(field.desc); if (IMMUTABLE_TYPE_SORTS.contains(type.getSort())) { continue; } if (type.getSort() != Type.OBJECT) { log.add("Odd sort: " + klass.name + "#" + field.name + ":" + field.desc); return true; } if (allClasses.keySet().contains(type.getInternalName())) { if (classesWithMutableDescendents.contains(type.getInternalName())) { log.add("Internal mutable field: " + klass.name + "#" + field.name + ":" + field.desc); return true; } } else { if (!EXTERNAL_IMMUTABLE_CLASSES.contains(type.getInternalName())) { log.add("External mutable field: " + klass.name + "#" + field.name + ":" + field.desc); return true; } } } return false; } private void analyzeClass(ClassNode klass) { if (trulyMutableClasses.contains(klass.name)) { return; } if (classIsDefinitelyMutable(klass)) { markClassTrulyMutable(klass.name); } } }