Use a context for transform state

9 files changed, 140 insertions, 132 deletions

diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/derived/DerivedConfiguration.java b/config-model/src/main/java/com/yahoo/searchdefinition/derived/DerivedConfiguration.java
index 118fc8b6211..fa202770e26 100644
--- a/config-model/src/main/java/com/yahoo/searchdefinition/derived/DerivedConfiguration.java
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/derived/DerivedConfiguration.java
@@ -63,11 +63,11 @@ public class DerivedConfiguration {
      */
     public DerivedConfiguration(Search search, List<Search> abstractSearchList, DeployLogger deployLogger, RankProfileRegistry rankProfileRegistry) {
         Validator.ensureNotNull("Search definition", search);
-        if (!search.isProcessed()) {
+        if ( ! search.isProcessed()) {
             throw new IllegalArgumentException("Search '" + search.getName() + "' not processed.");
         }
         this.search = search;
-        if (!search.isDocumentsOnly()) {
+        if ( ! search.isDocumentsOnly()) {
             streamingFields = new VsmFields(search);
             streamingSummary = new VsmSummary(search);
         }
@@ -160,15 +160,15 @@ public class DerivedConfiguration {
     public Search getSearch() {
         return search;
     }
-    
+
     public RankProfileList getRankProfileList() {
         return rankProfileList;
     }
-    
+
     public VsmSummary getVsmSummary() {
         return streamingSummary;
     }
-    
+
     public VsmFields getVsmFields() {
         return streamingFields;
     }
@@ -180,7 +180,7 @@ public class DerivedConfiguration {
     public Juniperrc getJuniperrc() {
         return juniperrc;
     }
-    
+
     public SummaryMap getSummaryMap() {
         return summaryMap;
     }
diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ConstantTensorTransformer.java b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ConstantTensorTransformer.java
index e061ead465e..f835e0a6ed1 100644
--- a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ConstantTensorTransformer.java
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ConstantTensorTransformer.java
@@ -8,11 +8,11 @@ import com.yahoo.searchlib.rankingexpression.rule.ExpressionNode;
 import com.yahoo.searchlib.rankingexpression.rule.NameNode;
 import com.yahoo.searchlib.rankingexpression.rule.ReferenceNode;
 import com.yahoo.searchlib.rankingexpression.transform.ExpressionTransformer;
+import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 
 /**
  * Transforms named references to constant tensors with the rank feature 'constant'.
@@ -23,53 +23,44 @@ public class ConstantTensorTransformer extends ExpressionTransformer {
 
     public static final String CONSTANT = "constant";
 
-    private final Map<String, Value> constants;
-    private final Map<String, String> rankPropertiesOutput;
-
-    public ConstantTensorTransformer(Map<String, Value> constants,
-                                     Map<String, String> rankPropertiesOutput) {
-        this.constants = constants;
-        this.rankPropertiesOutput = rankPropertiesOutput;
-    }
-
     @Override
-    public ExpressionNode transform(ExpressionNode node) {
+    public ExpressionNode transform(ExpressionNode node, TransformContext context) {
         if (node instanceof ReferenceNode) {
-            return transformFeature((ReferenceNode) node);
+            return transformFeature((ReferenceNode) node, (RankProfileTransformContext)context);
         } else if (node instanceof CompositeNode) {
-            return transformChildren((CompositeNode) node);
+            return transformChildren((CompositeNode) node, context);
         } else {
             return node;
         }
     }
 
-    private ExpressionNode transformFeature(ReferenceNode node) {
+    private ExpressionNode transformFeature(ReferenceNode node, RankProfileTransformContext context) {
         if (!node.getArguments().isEmpty()) {
-            return transformArguments(node);
+            return transformArguments(node, context);
         } else {
-            return transformConstantReference(node);
+            return transformConstantReference(node, context);
         }
     }
 
-    private ExpressionNode transformArguments(ReferenceNode node) {
+    private ExpressionNode transformArguments(ReferenceNode node, TransformContext context) {
         List<ExpressionNode> arguments = node.getArguments().expressions();
         List<ExpressionNode> transformedArguments = new ArrayList<>(arguments.size());
         for (ExpressionNode argument : arguments) {
-            transformedArguments.add(transform(argument));
+            transformedArguments.add(transform(argument, context));
         }
         return node.setArguments(transformedArguments);
     }
 
-    private ExpressionNode transformConstantReference(ReferenceNode node) {
-        Value value = constants.get(node.getName());
+    private ExpressionNode transformConstantReference(ReferenceNode node, RankProfileTransformContext context) {
+        Value value = context.constants().get(node.getName());
         if (value == null || !(value instanceof TensorValue)) {
             return node;
         }
         TensorValue tensorValue = (TensorValue)value;
         String featureName = CONSTANT + "(" + node.getName() + ")";
         String tensorType = tensorValue.asTensor().type().toString();
-        rankPropertiesOutput.put(featureName + ".value", tensorValue.toString());
-        rankPropertiesOutput.put(featureName + ".type", tensorType);
+        context.rankPropertiesOutput().put(featureName + ".value", tensorValue.toString());
+        context.rankPropertiesOutput().put(featureName + ".type", tensorType);
         return new ReferenceNode("constant", Arrays.asList(new NameNode(node.getName())), null);
     }
 
diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ExpressionTransforms.java b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ExpressionTransforms.java
index ee5cccccb29..d7a38f47766 100644
--- a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ExpressionTransforms.java
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/ExpressionTransforms.java
@@ -1,33 +1,44 @@
 package com.yahoo.searchdefinition.expressiontransforms;
 
+import com.google.common.collect.ImmutableList;
 import com.yahoo.searchdefinition.RankProfile;
 import com.yahoo.searchlib.rankingexpression.RankingExpression;
 import com.yahoo.searchlib.rankingexpression.evaluation.Value;
 import com.yahoo.searchlib.rankingexpression.transform.ConstantDereferencer;
+import com.yahoo.searchlib.rankingexpression.transform.ExpressionTransformer;
 import com.yahoo.searchlib.rankingexpression.transform.Simplifier;
+import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
 
+import java.util.List;
 import java.util.Map;
 
 /**
  * The transformations done on ranking expressions done at config time before passing them on to the Vespa
  * engine for execution.
  *
+ * An instance of this class has scope of one complete deployment.
+ *
  * @author bratseth
  */
 public class ExpressionTransforms {
 
+    private final List<ExpressionTransformer> transforms =
+            ImmutableList.of(new TensorFlowFeatureConverter(),
+                             new ConstantDereferencer(),
+                             new ConstantTensorTransformer(),
+                             new MacroInliner(),
+                             new MacroShadower(),
+                             new TensorTransformer(),
+                             new Simplifier());
+
     public RankingExpression transform(RankingExpression expression,
                                        RankProfile rankProfile,
                                        Map<String, Value> constants,
                                        Map<String, RankProfile.Macro> inlineMacros,
                                        Map<String, String> rankPropertiesOutput) {
-        expression = new TensorFlowFeatureConverter(rankProfile).transform(expression);
-        expression = new ConstantDereferencer(constants).transform(expression);
-        expression = new ConstantTensorTransformer(constants, rankPropertiesOutput).transform(expression);
-        expression = new MacroInliner(inlineMacros).transform(expression);
-        expression = new MacroShadower(rankProfile.getMacros()).transform(expression);
-        expression = new TensorTransformer(rankProfile).transform(expression);
-        expression = new Simplifier().transform(expression);
+        TransformContext context = new RankProfileTransformContext(rankProfile, constants, inlineMacros, rankPropertiesOutput);
+        for (ExpressionTransformer transformer : transforms)
+            expression = transformer.transform(expression, context);
         return expression;
     }
 
diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroInliner.java b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroInliner.java
index a3933e6f8e2..6702955bae3 100644
--- a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroInliner.java
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroInliner.java
@@ -6,8 +6,7 @@ import com.yahoo.searchlib.rankingexpression.rule.CompositeNode;
 import com.yahoo.searchlib.rankingexpression.rule.ExpressionNode;
 import com.yahoo.searchlib.rankingexpression.rule.ReferenceNode;
 import com.yahoo.searchlib.rankingexpression.transform.ExpressionTransformer;
-
-import java.util.Map;
+import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
 
 /**
  * Inlines macros in ranking expressions
@@ -16,25 +15,19 @@ import java.util.Map;
  */
 public class MacroInliner extends ExpressionTransformer {
 
-    private final Map<String, RankProfile.Macro> macros;
-
-    public MacroInliner(Map<String, RankProfile.Macro> macros) {
-        this.macros = macros;
-    }
-
     @Override
-    public ExpressionNode transform(ExpressionNode node) {
+    public ExpressionNode transform(ExpressionNode node, TransformContext context) {
         if (node instanceof ReferenceNode)
-            return transformFeatureNode((ReferenceNode)node);
+            return transformFeatureNode((ReferenceNode)node, (RankProfileTransformContext)context);
         if (node instanceof CompositeNode)
-            return transformChildren((CompositeNode)node);
+            return transformChildren((CompositeNode)node, context);
         return node;
     }
 
-    private ExpressionNode transformFeatureNode(ReferenceNode feature) {
-        RankProfile.Macro macro = macros.get(feature.getName());
+    private ExpressionNode transformFeatureNode(ReferenceNode feature, RankProfileTransformContext context) {
+        RankProfile.Macro macro = context.inlineMacros().get(feature.getName());
         if (macro == null) return feature;
-        return transform(macro.getRankingExpression().getRoot()); // inline recursively and return
+        return transform(macro.getRankingExpression().getRoot(), context); // inline recursively and return
     }
 
 }
diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroShadower.java b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroShadower.java
index 1d9769d0d78..6eabb5ddcd4 100644
--- a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroShadower.java
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/MacroShadower.java
@@ -3,10 +3,12 @@ package com.yahoo.searchdefinition.expressiontransforms;
 
 import com.yahoo.searchdefinition.RankProfile;
 import com.yahoo.searchlib.rankingexpression.RankingExpression;
-import com.yahoo.searchlib.rankingexpression.rule.*;
+import com.yahoo.searchlib.rankingexpression.rule.CompositeNode;
+import com.yahoo.searchlib.rankingexpression.rule.ExpressionNode;
+import com.yahoo.searchlib.rankingexpression.rule.FunctionNode;
+import com.yahoo.searchlib.rankingexpression.rule.ReferenceNode;
 import com.yahoo.searchlib.rankingexpression.transform.ExpressionTransformer;
-
-import java.util.Map;
+import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
 
 /**
  * Transforms function nodes to reference nodes if a macro shadows a built-in function.
@@ -23,44 +25,38 @@ import java.util.Map;
  */
 public class MacroShadower extends ExpressionTransformer {
 
-    private final Map<String, RankProfile.Macro> macros;
-
-    public MacroShadower(Map<String, RankProfile.Macro> macros) {
-        this.macros = macros;
-    }
-
     @Override
-    public RankingExpression transform(RankingExpression expression) {
+    public RankingExpression transform(RankingExpression expression, TransformContext context) {
         String name = expression.getName();
         ExpressionNode node = expression.getRoot();
-        ExpressionNode result = transform(node);
+        ExpressionNode result = transform(node, context);
         return new RankingExpression(name, result);
     }
 
     @Override
-    public ExpressionNode transform(ExpressionNode node) {
+    public ExpressionNode transform(ExpressionNode node, TransformContext context) {
         if (node instanceof FunctionNode)
-            return transformFunctionNode((FunctionNode) node);
+            return transformFunctionNode((FunctionNode) node, context);
         if (node instanceof CompositeNode)
-            return transformChildren((CompositeNode)node);
+            return transformChildren((CompositeNode)node, context);
         return node;
     }
 
-    protected ExpressionNode transformFunctionNode(FunctionNode function) {
+    protected ExpressionNode transformFunctionNode(FunctionNode function, TransformContext context) {
         String name = function.getFunction().toString();
-        RankProfile.Macro macro = macros.get(name);
+        RankProfile.Macro macro = ((RankProfileTransformContext)context).rankProfile().getMacros().get(name);
         if (macro == null) {
-            return transformChildren(function);
+            return transformChildren(function, context);
         }
 
         int functionArity = function.getFunction().arity();
         int macroArity = macro.getFormalParams() != null ? macro.getFormalParams().size() : 0;
         if (functionArity != macroArity) {
-            return transformChildren(function);
+            return transformChildren(function, context);
         }
 
         ReferenceNode node = new ReferenceNode(name, function.children(), null);
-        return transformChildren(node);
+        return transformChildren(node, context);
     }
 
 }
diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/RankProfileTransformContext.java b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/RankProfileTransformContext.java
new file mode 100644
index 00000000000..fb996d70607
--- /dev/null
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/RankProfileTransformContext.java
@@ -0,0 +1,34 @@
+package com.yahoo.searchdefinition.expressiontransforms;
+
+import com.yahoo.searchdefinition.RankProfile;
+import com.yahoo.searchlib.rankingexpression.evaluation.Value;
+import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
+
+import java.util.Map;
+
+/**
+ * Extends the transform context with rank profile information
+ *
+ * @author bratseth
+ */
+public class RankProfileTransformContext extends TransformContext {
+
+    private final RankProfile rankProfile;
+    private final Map<String, RankProfile.Macro> inlineMacros;
+    private final Map<String, String> rankPropertiesOutput;
+
+    RankProfileTransformContext(RankProfile rankProfile,
+                                Map<String, Value> constants,
+                                Map<String, RankProfile.Macro> inlineMacros,
+                                Map<String, String> rankPropertiesOutput) {
+        super(constants);
+        this.rankProfile = rankProfile;
+        this.inlineMacros = inlineMacros;
+        this.rankPropertiesOutput = rankPropertiesOutput;
+    }
+
+    public RankProfile rankProfile() { return rankProfile; }
+    public Map<String, RankProfile.Macro> inlineMacros() { return inlineMacros; }
+    public Map<String, String> rankPropertiesOutput() { return rankPropertiesOutput; }
+
+}
diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorFlowFeatureConverter.java b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorFlowFeatureConverter.java
index e5886030d44..b7033d4ad9f 100644
--- a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorFlowFeatureConverter.java
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorFlowFeatureConverter.java
@@ -1,6 +1,5 @@
 package com.yahoo.searchdefinition.expressiontransforms;
 
-import com.yahoo.searchdefinition.RankProfile;
 import com.yahoo.searchlib.rankingexpression.evaluation.TensorValue;
 import com.yahoo.searchlib.rankingexpression.integration.tensorflow.ImportResult;
 import com.yahoo.searchlib.rankingexpression.integration.tensorflow.TensorFlowImporter;
@@ -10,6 +9,7 @@ import com.yahoo.searchlib.rankingexpression.rule.ConstantNode;
 import com.yahoo.searchlib.rankingexpression.rule.ExpressionNode;
 import com.yahoo.searchlib.rankingexpression.rule.ReferenceNode;
 import com.yahoo.searchlib.rankingexpression.transform.ExpressionTransformer;
+import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
 
 import java.util.Map;
 import java.util.Optional;
@@ -24,23 +24,18 @@ import java.util.Optional;
 public class TensorFlowFeatureConverter extends ExpressionTransformer {
 
     private final TensorFlowImporter tensorFlowImporter = new TensorFlowImporter();
-    private final RankProfile profile;
-
-    public TensorFlowFeatureConverter(RankProfile profile) {
-        this.profile = profile;
-    }
 
     @Override
-    public ExpressionNode transform(ExpressionNode node) {
+    public ExpressionNode transform(ExpressionNode node, TransformContext context) {
         if (node instanceof ReferenceNode)
-            return transformFeature((ReferenceNode) node);
+            return transformFeature((ReferenceNode) node, (RankProfileTransformContext)context);
         else if (node instanceof CompositeNode)
-            return super.transformChildren((CompositeNode) node);
+            return super.transformChildren((CompositeNode) node, context);
         else
             return node;
     }
 
-    private ExpressionNode transformFeature(ReferenceNode feature) {
+    private ExpressionNode transformFeature(ReferenceNode feature, RankProfileTransformContext context) {
         try {
             if ( ! feature.getName().equals("tensorflow")) return feature;
 
@@ -48,15 +43,16 @@ public class TensorFlowFeatureConverter extends ExpressionTransformer {
                 throw new IllegalArgumentException("A tensorflow node must take an argument pointing to " +
                                                    "the tensorflow model directory under [application]/models");
 
-            // Find the specified expression
             ImportResult result = tensorFlowImporter.importModel(asString(feature.getArguments().expressions().get(0)));
+
+            // Find the specified expression
             ImportResult.Signature signature = chooseOrDefault("signatures", result.signatures(),
                                                                optionalArgument(1, feature.getArguments()));
             String output = chooseOrDefault("outputs", signature.outputs(),
                                             optionalArgument(2, feature.getArguments()));
 
             // Add all constants
-            result.constants().forEach((k, v) -> profile.addConstantTensor(k, new TensorValue(v)));
+            result.constants().forEach((k, v) -> context.rankProfile().addConstantTensor(k, new TensorValue(v)));
 
             return result.expressions().get(output).getRoot();
         }
diff --git a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorTransformer.java b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorTransformer.java
index 70a7372dbe9..971c2c4f218 100644
--- a/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorTransformer.java
+++ b/config-model/src/main/java/com/yahoo/searchdefinition/expressiontransforms/TensorTransformer.java
@@ -3,7 +3,6 @@ package com.yahoo.searchdefinition.expressiontransforms;
 
 import com.yahoo.searchdefinition.RankProfile;
 import com.yahoo.searchdefinition.RankingConstant;
-import com.yahoo.searchdefinition.Search;
 import com.yahoo.searchdefinition.document.Attribute;
 import com.yahoo.searchlib.rankingexpression.evaluation.Context;
 import com.yahoo.searchlib.rankingexpression.evaluation.DoubleValue;
@@ -17,12 +16,12 @@ import com.yahoo.searchlib.rankingexpression.rule.FunctionNode;
 import com.yahoo.searchlib.rankingexpression.rule.ReferenceNode;
 import com.yahoo.searchlib.rankingexpression.rule.TensorFunctionNode;
 import com.yahoo.searchlib.rankingexpression.transform.ExpressionTransformer;
+import com.yahoo.searchlib.rankingexpression.transform.TransformContext;
 import com.yahoo.tensor.Tensor;
 import com.yahoo.tensor.TensorType;
 import com.yahoo.tensor.functions.Reduce;
 
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 
 /**
@@ -36,32 +35,22 @@ import java.util.Optional;
  */
 public class TensorTransformer extends ExpressionTransformer {
 
-    private Search search;
-    private RankProfile rankprofile;
-    private Map<String, RankProfile.Macro> macros;
-
-    public TensorTransformer(RankProfile rankprofile) {
-        this.rankprofile = rankprofile;
-        this.search = rankprofile.getSearch();
-        this.macros = rankprofile.getMacros();
-    }
-
     @Override
-    public ExpressionNode transform(ExpressionNode node) {
+    public ExpressionNode transform(ExpressionNode node, TransformContext context) {
         if (node instanceof CompositeNode) {
-            node = transformChildren((CompositeNode) node);
+            node = transformChildren((CompositeNode) node, context);
         }
         if (node instanceof FunctionNode) {
-            node = transformFunctionNode((FunctionNode) node);
+            node = transformFunctionNode((FunctionNode) node, ((RankProfileTransformContext)context).rankProfile());
         }
         return node;
     }
 
-    private ExpressionNode transformFunctionNode(FunctionNode node) {
+    private ExpressionNode transformFunctionNode(FunctionNode node, RankProfile profile) {
         switch (node.getFunction()) {
             case min:
             case max:
-                return transformMaxAndMinFunctionNode(node);
+                return transformMaxAndMinFunctionNode(node, profile);
         }
         return node;
     }
@@ -80,7 +69,7 @@ public class TensorTransformer extends ExpressionTransformer {
      * There is currently no guarantee that all cases will be found. For
      * instance, if-statements are problematic.
      */
-    private ExpressionNode transformMaxAndMinFunctionNode(FunctionNode node) {
+    private ExpressionNode transformMaxAndMinFunctionNode(FunctionNode node, RankProfile profile) {
         if (node.children().size() != 2) {
             return node;
         }
@@ -88,7 +77,7 @@ public class TensorTransformer extends ExpressionTransformer {
         Optional<String> dimension = dimensionName(node.children().get(1));
         if (dimension.isPresent()) {
             try {
-                Context context = buildContext(arg1);
+                Context context = buildContext(arg1, profile);
                 Value value = arg1.evaluate(context);
                 if (isTensorWithDimension(value, dimension.get())) {
                     return replaceMaxAndMinFunction(node);
@@ -110,12 +99,10 @@ public class TensorTransformer extends ExpressionTransformer {
     }
 
     private boolean isTensorWithDimension(Value value, String dimension) {
-        if (value instanceof TensorValue) {
-            Tensor tensor = ((TensorValue) value).asTensor();
-            TensorType type = tensor.type();
-            return type.dimensionNames().contains(dimension);
-        }
-        return false;
+        if (value instanceof TensorValue)
+            return value.asTensor().type().dimensionNames().contains(dimension);
+        else
+            return false;
     }
 
     private ExpressionNode replaceMaxAndMinFunction(FunctionNode node) {
@@ -133,9 +120,9 @@ public class TensorTransformer extends ExpressionTransformer {
      * Creates an evaluation context by iterating through the expression tree, and
      * adding dummy values with correct types to the context.
      */
-    private Context buildContext(ExpressionNode node) {
+    private Context buildContext(ExpressionNode node, RankProfile profile) {
         Context context = new MapContext();
-        addRoot(node, context);
+        addRoot(node, context, profile);
         return context;
     }
 
@@ -152,28 +139,28 @@ public class TensorTransformer extends ExpressionTransformer {
         return new TensorValue(empty);
     }
 
-    private void addRoot(ExpressionNode node, Context context) {
-        addChildren(node, context);
+    private void addRoot(ExpressionNode node, Context context, RankProfile profile) {
+        addChildren(node, context, profile);
         if (node instanceof ReferenceNode) {
             ReferenceNode referenceNode = (ReferenceNode) node;
-            addIfAttribute(referenceNode, context);
-            addIfConstant(referenceNode, context);
-            addIfQuery(referenceNode, context);
+            addIfAttribute(referenceNode, context, profile);
+            addIfConstant(referenceNode, context, profile);
+            addIfQuery(referenceNode, context, profile);
             addIfTensorFrom(referenceNode, context);
-            addIfMacro(referenceNode, context);
+            addIfMacro(referenceNode, context, profile);
         }
     }
 
-    private void addChildren(ExpressionNode node, Context context) {
+    private void addChildren(ExpressionNode node, Context context, RankProfile profile) {
         if (node instanceof CompositeNode) {
             List<ExpressionNode> children = ((CompositeNode) node).children();
             for (ExpressionNode child : children) {
-                addRoot(child, context);
+                addRoot(child, context, profile);
             }
         }
     }
 
-    private void addIfAttribute(ReferenceNode node, Context context) {
+    private void addIfAttribute(ReferenceNode node, Context context, RankProfile profile) {
         if (!node.getName().equals("attribute")) {
             return;
         }
@@ -181,7 +168,7 @@ public class TensorTransformer extends ExpressionTransformer {
             return;
         }
         String attribute = node.children().get(0).toString();
-        Attribute a = search.getAttribute(attribute);
+        Attribute a = profile.getSearch().getAttribute(attribute);
         if (a == null) {
             return;
         }
@@ -196,7 +183,7 @@ public class TensorTransformer extends ExpressionTransformer {
         context.put(node.toString(), v);
     }
 
-    private void addIfConstant(ReferenceNode node, Context context) {
+    private void addIfConstant(ReferenceNode node, Context context, RankProfile profile) {
         if (!node.getName().equals(ConstantTensorTransformer.CONSTANT)) {
             return;
         }
@@ -208,25 +195,25 @@ public class TensorTransformer extends ExpressionTransformer {
             child = ((CompositeNode) child).children().get(0);
         }
         String name = child.toString();
-        addIfConstantInRankProfile(name, node, context);
-        addIfConstantInRankingConstants(name, node, context);
+        addIfConstantInRankProfile(name, node, context, profile);
+        addIfConstantInRankingConstants(name, node, context, profile);
     }
 
-    private void addIfConstantInRankProfile(String name, ReferenceNode node, Context context) {
-        if (rankprofile.getConstants().containsKey(name)) {
-            context.put(node.toString(), rankprofile.getConstants().get(name));
+    private void addIfConstantInRankProfile(String name, ReferenceNode node, Context context, RankProfile profile) {
+        if (profile.getConstants().containsKey(name)) {
+            context.put(node.toString(), profile.getConstants().get(name));
         }
     }
 
-    private void addIfConstantInRankingConstants(String name, ReferenceNode node, Context context) {
-        for (RankingConstant rankingConstant : search.getRankingConstants()) {
+    private void addIfConstantInRankingConstants(String name, ReferenceNode node, Context context, RankProfile profile) {
+        for (RankingConstant rankingConstant : profile.getSearch().getRankingConstants()) {
             if (rankingConstant.getName().equals(name)) {
                 context.put(node.toString(), emptyTensorValue(rankingConstant.getTensorType()));
             }
         }
     }
 
-    private void addIfQuery(ReferenceNode node, Context context) {
+    private void addIfQuery(ReferenceNode node, Context context, RankProfile profile) {
         if (!node.getName().equals("query")) {
             return;
         }
@@ -234,8 +221,8 @@ public class TensorTransformer extends ExpressionTransformer {
             return;
         }
         String name = node.children().get(0).toString();
-        if (rankprofile.getQueryFeatureTypes().containsKey(name)) {
-            String type = rankprofile.getQueryFeatureTypes().get(name);
+        if (profile.getQueryFeatureTypes().containsKey(name)) {
+            String type = profile.getQueryFeatureTypes().get(name);
             Value v;
             if (type.contains("tensor")) {
                 v = emptyTensorValue(TensorType.fromSpec(type));
@@ -267,13 +254,13 @@ public class TensorTransformer extends ExpressionTransformer {
         context.put(node.toString(), emptyTensorValue(type));
     }
 
-    private void addIfMacro(ReferenceNode node, Context context) {
-        RankProfile.Macro macro = macros.get(node.getName());
+    private void addIfMacro(ReferenceNode node, Context context, RankProfile profile) {
+        RankProfile.Macro macro = profile.getMacros().get(node.getName());
         if (macro == null) {
             return;
         }
         ExpressionNode root = macro.getRankingExpression().getRoot();
-        Context macroContext = buildContext(root);
+        Context macroContext = buildContext(root, profile);
         addMacroArguments(node, context, macro, macroContext);
         Value value = root.evaluate(macroContext);
         context.put(node.toString(), value);
diff --git a/config-model/src/test/java/com/yahoo/searchdefinition/processing/TensorTransformTestCase.java b/config-model/src/test/java/com/yahoo/searchdefinition/processing/TensorTransformTestCase.java
index e5693d24f0f..475fee62177 100644
--- a/config-model/src/test/java/com/yahoo/searchdefinition/processing/TensorTransformTestCase.java
+++ b/config-model/src/test/java/com/yahoo/searchdefinition/processing/TensorTransformTestCase.java
@@ -92,7 +92,7 @@ public class TensorTransformTestCase extends SearchDefinitionTestCase {
 
     private void assertContainsExpression(String expr, String transformedExpression) throws ParseException {
         assertTrue("Expected expression '" + transformedExpression + "' not found",
-                containsExpression(expr, transformedExpression));
+                   containsExpression(expr, transformedExpression));
     }
 
     private boolean containsExpression(String expr, String transformedExpression) throws ParseException {