| // Copyright 2016 The Bazel Authors. 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.devtools.build.lib.query2.engine; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.devtools.build.lib.query2.engine.QueryEnvironment.Argument; |
| |
| /** |
| * Performs an arbitrary contextual transformation of a {@link QueryExpression}. |
| * |
| * <p>For each subclass of {@link QueryExpression}, there's a corresponding {@link #visit} overload |
| * that transforms a node of that type. By default, this method recursively applies this {@link |
| * QueryExpressionMapper}'s transformation in a structure-preserving manner (trying to maintain |
| * reference-equality, as an optimization). Subclasses of {@link QueryExpressionMapper} can override |
| * these methods in order to implement an arbitrary transformation. |
| */ |
| public abstract class QueryExpressionMapper<C> |
| implements QueryExpressionVisitor<QueryExpression, C> { |
| |
| @Override |
| public QueryExpression visit(TargetLiteral targetLiteral, C context) { |
| return targetLiteral; |
| } |
| |
| @Override |
| public QueryExpression visit(BinaryOperatorExpression binaryOperatorExpression, C context) { |
| boolean changed = false; |
| ImmutableList.Builder<QueryExpression> mappedOperandsBuilder = ImmutableList.builder(); |
| for (QueryExpression operand : binaryOperatorExpression.getOperands()) { |
| QueryExpression mappedOperand = operand.accept(this, context); |
| if (mappedOperand != operand) { |
| changed = true; |
| } |
| mappedOperandsBuilder.add(mappedOperand); |
| } |
| return changed |
| ? new BinaryOperatorExpression( |
| binaryOperatorExpression.getOperator(), mappedOperandsBuilder.build()) |
| : binaryOperatorExpression; |
| } |
| |
| @Override |
| public QueryExpression visit(FunctionExpression functionExpression, C context) { |
| boolean changed = false; |
| ImmutableList.Builder<Argument> mappedArgumentBuilder = ImmutableList.builder(); |
| for (Argument argument : functionExpression.getArgs()) { |
| switch (argument.getType()) { |
| case EXPRESSION: |
| { |
| QueryExpression expr = argument.getExpression(); |
| QueryExpression mappedExpression = expr.accept(this, context); |
| mappedArgumentBuilder.add(Argument.of(mappedExpression)); |
| if (expr != mappedExpression) { |
| changed = true; |
| } |
| break; |
| } |
| default: |
| mappedArgumentBuilder.add(argument); |
| break; |
| } |
| } |
| return changed |
| ? new FunctionExpression(functionExpression.getFunction(), mappedArgumentBuilder.build()) |
| : functionExpression; |
| } |
| |
| @Override |
| public QueryExpression visit(LetExpression letExpression, C context) { |
| boolean changed = false; |
| QueryExpression mappedVarExpr = letExpression.getVarExpr().accept(this, context); |
| if (mappedVarExpr != letExpression.getVarExpr()) { |
| changed = true; |
| } |
| QueryExpression mappedBodyExpr = letExpression.getBodyExpr().accept(this, context); |
| if (mappedBodyExpr != letExpression.getBodyExpr()) { |
| changed = true; |
| } |
| return changed |
| ? new LetExpression(letExpression.getVarName(), mappedVarExpr, mappedBodyExpr) |
| : letExpression; |
| } |
| |
| @Override |
| public QueryExpression visit(SetExpression setExpression, C context) { |
| return setExpression; |
| } |
| |
| public static QueryExpressionMapper<Void> identity() { |
| return IdentityMapper.INSTANCE; |
| } |
| |
| /** |
| * Returns a {@link QueryExpressionMapper} which applies all the mappings provided by {@code |
| * mappers}, in the reverse order of mapper array. |
| */ |
| public static <C> QueryExpressionMapper<C> compose( |
| ImmutableList<QueryExpressionMapper<C>> mappers) { |
| return new ComposedQueryExpressionMapper<>(mappers); |
| } |
| |
| private static class ComposedQueryExpressionMapper<C> extends QueryExpressionMapper<C> { |
| private final ImmutableList<QueryExpressionMapper<C>> mappers; |
| |
| private ComposedQueryExpressionMapper(ImmutableList<QueryExpressionMapper<C>> mappers) { |
| this.mappers = mappers; |
| } |
| |
| @Override |
| public QueryExpression visit(TargetLiteral targetLiteral, C context) { |
| return mapAll(targetLiteral, mappers, context); |
| } |
| |
| @Override |
| public QueryExpression visit(BinaryOperatorExpression binaryOperatorExpression, C context) { |
| return mapAll(binaryOperatorExpression, mappers, context); |
| } |
| |
| @Override |
| public QueryExpression visit(FunctionExpression functionExpression, C context) { |
| return mapAll(functionExpression, mappers, context); |
| } |
| |
| @Override |
| public QueryExpression visit(LetExpression letExpression, C context) { |
| return mapAll(letExpression, mappers, context); |
| } |
| |
| @Override |
| public QueryExpression visit(SetExpression setExpression, C context) { |
| return mapAll(setExpression, mappers, context); |
| } |
| |
| private static <C> QueryExpression mapAll( |
| QueryExpression expression, ImmutableList<QueryExpressionMapper<C>> mappers, C context) { |
| QueryExpression expr = expression; |
| for (int i = mappers.size() - 1; i >= 0; i--) { |
| expr = expr.accept(mappers.get(i), context); |
| } |
| |
| return expr; |
| } |
| } |
| |
| private static class IdentityMapper extends QueryExpressionMapper<Void> { |
| private static final IdentityMapper INSTANCE = new IdentityMapper(); |
| |
| private IdentityMapper() { |
| } |
| |
| @Override |
| public QueryExpression visit(TargetLiteral targetLiteral, Void context) { |
| return targetLiteral; |
| } |
| |
| @Override |
| public QueryExpression visit(BinaryOperatorExpression binaryOperatorExpression, Void context) { |
| return binaryOperatorExpression; |
| } |
| |
| @Override |
| public QueryExpression visit(FunctionExpression functionExpression, Void context) { |
| return functionExpression; |
| } |
| |
| @Override |
| public QueryExpression visit(LetExpression letExpression, Void context) { |
| return letExpression; |
| } |
| |
| @Override |
| public QueryExpression visit(SetExpression setExpression, Void context) { |
| return setExpression; |
| } |
| } |
| } |
| |