Java tutorial
/* * Copyright 2014 Google Inc. All rights reserved. * * 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.google.errorprone.refaster; import static com.google.common.base.Preconditions.checkNotNull; import com.google.auto.value.AutoValue; import com.google.common.base.Function; import com.google.common.base.Functions; import com.google.common.base.Optional; import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.sun.source.tree.IdentifierTree; import com.sun.source.tree.Tree; import com.sun.source.tree.TreeVisitor; import com.sun.tools.javac.tree.JCTree; import com.sun.tools.javac.tree.JCTree.JCExpression; import com.sun.tools.javac.tree.JCTree.JCIdent; import com.sun.tools.javac.tree.TreeCopier; import com.sun.tools.javac.tree.TreeMaker; import com.sun.tools.javac.util.Context; import com.sun.tools.javac.util.List; import com.sun.tools.javac.util.Names; import java.util.Map; /** * {@code UTree} representation of an invocation of a placeholder method. * * @author lowasser@google.com (Louis Wasserman) */ @AutoValue public abstract class UPlaceholderExpression extends UExpression { static UPlaceholderExpression create(PlaceholderMethod placeholder, Iterable<? extends UExpression> arguments) { ImmutableList<UVariableDecl> placeholderParams = placeholder.parameters().asList(); ImmutableList<UExpression> argumentsList = ImmutableList.copyOf(arguments); ImmutableMap.Builder<UVariableDecl, UExpression> builder = ImmutableMap.builder(); for (int i = 0; i < placeholderParams.size(); i++) { builder.put(placeholderParams.get(i), argumentsList.get(i)); } return new AutoValue_UPlaceholderExpression(placeholder, builder.build()); } abstract PlaceholderMethod placeholder(); abstract ImmutableMap<UVariableDecl, UExpression> arguments(); public static final class PlaceholderParamIdent extends JCIdent { final UVariableDecl param; PlaceholderParamIdent(UVariableDecl param, Context context) { super(Names.instance(context).fromString(param.getName().contents()), null); this.param = checkNotNull(param); } } static class UncheckedCouldNotResolveImportException extends RuntimeException { UncheckedCouldNotResolveImportException(CouldNotResolveImportException e) { super(e); } @Override public synchronized CouldNotResolveImportException getCause() { return (CouldNotResolveImportException) super.getCause(); } } static TreeCopier<Inliner> copier(final Map<UVariableDecl, UExpression> arguments, Inliner inliner) { return new TreeCopier<Inliner>(inliner.maker()) { @Override public <T extends JCTree> T copy(T tree, Inliner inliner) { if (tree == null) { return null; } T result = super.copy(tree, inliner); if (result.toString().equals(tree.toString())) { return tree; } else { return result; } } @Override public JCTree visitIdentifier(IdentifierTree node, Inliner inliner) { if (node instanceof PlaceholderParamIdent) { try { return arguments.get(((PlaceholderParamIdent) node).param).inline(inliner); } catch (CouldNotResolveImportException e) { throw new UncheckedCouldNotResolveImportException(e); } } else { return super.visitIdentifier(node, inliner); } } }; } @Override public JCExpression inline(Inliner inliner) throws CouldNotResolveImportException { /* * Copy the original source bound to the placeholder, except anywhere we matched a placeholder * parameter, replace that with the corresponding expression in this invocation. */ try { return copier(arguments(), inliner).copy(inliner.getBinding(placeholder().exprKey()), inliner); } catch (UncheckedCouldNotResolveImportException e) { throw e.getCause(); } } @Override public Kind getKind() { return Kind.OTHER; } @Override public <R, D> R accept(TreeVisitor<R, D> visitor, D data) { return visitor.visitOther(this, data); } @Override protected Choice<Unifier> defaultAction(Tree node, Unifier unifier) { // for now we only match JCExpressions if (placeholder().returnType().equals(UPrimitiveType.VOID) || !(node instanceof JCExpression)) { return Choice.none(); } final JCExpression expr = (JCExpression) node; PlaceholderVerificationVisitor verification = new PlaceholderVerificationVisitor( Collections2.transform(placeholder().requiredParameters(), Functions.forMap(arguments())), arguments().values()); if (!verification.scan(node, unifier) || !verification.allRequiredMatched()) { return Choice.none(); } /* * We copy the tree with a TreeCopier, replacing matches for the parameters with * PlaceholderParamIdents, and updating unifierHolder as we unify things, including forbidding * references to local variables, etc. */ Choice<? extends PlaceholderUnificationVisitor.State<? extends JCExpression>> states = PlaceholderUnificationVisitor .create(TreeMaker.instance(unifier.getContext()), arguments()).unifyExpression(expr, PlaceholderUnificationVisitor.State.create(List.<UVariableDecl>nil(), unifier, null)); return states.thenOption( new Function<PlaceholderUnificationVisitor.State<? extends JCExpression>, Optional<Unifier>>() { @Override public Optional<Unifier> apply( PlaceholderUnificationVisitor.State<? extends JCExpression> state) { if (ImmutableSet.copyOf(state.seenParameters()) .containsAll(placeholder().requiredParameters())) { Unifier resultUnifier = state.unifier(); JCExpression prevBinding = resultUnifier.getBinding(placeholder().exprKey()); if (prevBinding != null) { return prevBinding.toString().equals(state.result().toString()) ? Optional.of(resultUnifier) : Optional.<Unifier>absent(); } JCExpression result = state.result(); if (!placeholder().matcher().matches(result, UMatches.makeVisitorState(expr, resultUnifier))) { return Optional.absent(); } result.type = expr.type; resultUnifier.putBinding(placeholder().exprKey(), result); return Optional.of(resultUnifier); } else { return Optional.absent(); } } }); } }