| 
                                Change Parameter Type	output : Symbol to output : VariableReferenceExpression in method private addAggregation(output VariableReferenceExpression, expression Expression, inputTypes List<Type>, mask Optional<Symbol>) : AggregationBuilder in class com.facebook.presto.sql.planner.iterative.rule.test.PlanBuilder.AggregationBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	newNonDistinctAggregateSymbols : Map<Symbol,Symbol> to newNonDistinctAggregateVariables : Map<VariableReferenceExpression,VariableReferenceExpression> in method public setNewNonDistinctAggregateSymbols(newNonDistinctAggregateVariables Map<VariableReferenceExpression,VariableReferenceExpression>) : void in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.AggregateInfo | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregationOutputSymbolsMap : Map<Symbol,Symbol> to aggregationOutputVariablesMap : Map<VariableReferenceExpression,VariableReferenceExpression> in method private createProjectNode(source AggregationNode, aggregateInfo AggregateInfo, distinctSymbol Symbol, groupSymbol Symbol, groupBySymbols List<Symbol>, aggregationOutputVariablesMap Map<VariableReferenceExpression,VariableReferenceExpression>) : ProjectNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	assignments : Map<Symbol,Aggregation> to assignments : Map<VariableReferenceExpression,Aggregation> in method private outputsAsInputs(assignments Map<VariableReferenceExpression,Aggregation>) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	output : Symbol to output : VariableReferenceExpression in method public addAggregation(output VariableReferenceExpression, expression Expression, inputTypes List<Type>, mask Symbol) : AggregationBuilder in class com.facebook.presto.sql.planner.iterative.rule.test.PlanBuilder.AggregationBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method private checkFunctionSignature(aggregations Map<VariableReferenceExpression,Aggregation>) : void in class com.facebook.presto.sql.planner.sanity.TypeValidator.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	assignments : Map<Symbol,Aggregation> to assignments : Map<VariableReferenceExpression,Aggregation> in method private inputsAsOutputs(assignments Map<VariableReferenceExpression,Aggregation>, types TypeProvider) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method private createAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, step Step, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, source PhysicalOperation, context LocalExecutionPlanContext, useSystemMemory boolean) : AggregationOperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method public groupBy(sourceStats PlanNodeStatsEstimate, groupBySymbols Collection<Symbol>, aggregations Map<VariableReferenceExpression,Aggregation>) : PlanNodeStatsEstimate in class com.facebook.presto.cost.AggregationStatsRule | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregationOutputs : List<Symbol> to aggregationOutputs : List<VariableReferenceExpression> in method private computeCounts(sourceNode UnionNode, originalColumns List<Symbol>, markers List<VariableReferenceExpression>, aggregationOutputs List<VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.ImplementIntersectAndExceptAsUnion.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregationOutputSymbolsMapBuilder : ImmutableMap.Builder<Symbol,Symbol> to aggregationOutputSymbolsMapBuilder : ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression> in method private createNonDistinctAggregation(aggregateInfo AggregateInfo, distinctSymbol Symbol, duplicatedDistinctSymbol Symbol, groupByKeys Set<Symbol>, groupIdNode GroupIdNode, originalNode MarkDistinctNode, aggregationOutputSymbolsMapBuilder ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method public AggregationNode(id PlanNodeId, source PlanNode, aggregations Map<VariableReferenceExpression,Aggregation>, groupingSets GroupingSetDescriptor, preGroupedSymbols List<Symbol>, step Step, hashVariable Optional<VariableReferenceExpression>, groupIdSymbol Optional<Symbol>) in class com.facebook.presto.sql.planner.plan.AggregationNode | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method private checkAggregation(aggregations Map<VariableReferenceExpression,Aggregation>) : void in class com.facebook.presto.sql.planner.sanity.TypeValidator.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	remainingSources : List<Symbol> to remainingSources : List<VariableReferenceExpression> in method private addFilterForExcept(aggregation AggregationNode, firstSource VariableReferenceExpression, remainingSources List<VariableReferenceExpression>) : FilterNode in class com.facebook.presto.sql.planner.optimizations.ImplementIntersectAndExceptAsUnion.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method public AggregateInfo(groupBySymbols List<Symbol>, mask Symbol, aggregations Map<VariableReferenceExpression,Aggregation>) in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.AggregateInfo | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method private createHashAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, globalGroupingSets Set<Integer>, groupbySymbols List<Symbol>, step Step, hashVariable Optional<VariableReferenceExpression>, groupIdSymbol Optional<Symbol>, source PhysicalOperation, hasDefaultOutput boolean, spillEnabled boolean, isStreamable boolean, unspillMemoryLimit DataSize, context LocalExecutionPlanContext, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, expectedGroups int, maxPartialAggregationMemorySize Optional<DataSize>, useSystemMemory boolean) : OperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	newDistinctAggregateSymbol : Symbol to newDistinctAggregateVariable : VariableReferenceExpression in method public setNewDistinctAggregateSymbol(newDistinctAggregateVariable VariableReferenceExpression) : void in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.AggregateInfo | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	output : Symbol to output : VariableReferenceExpression in method public addAggregation(output VariableReferenceExpression, aggregation Aggregation) : AggregationBuilder in class com.facebook.presto.sql.planner.iterative.rule.test.PlanBuilder.AggregationBuilder | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	firstSource : Symbol to firstSource : VariableReferenceExpression in method private addFilterForExcept(aggregation AggregationNode, firstSource VariableReferenceExpression, remainingSources List<VariableReferenceExpression>) : FilterNode in class com.facebook.presto.sql.planner.optimizations.ImplementIntersectAndExceptAsUnion.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	aggregations : Map<Symbol,AggregationNode.Aggregation> to aggregations : Map<VariableReferenceExpression,AggregationNode.Aggregation> in method private allAggregationsOn(aggregations Map<VariableReferenceExpression,AggregationNode.Aggregation>, symbols List<Symbol>) : boolean in class com.facebook.presto.sql.planner.iterative.rule.PushPartialAggregationThroughJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Parameter Type	output : Symbol to output : VariableReferenceExpression in method public addAggregation(output VariableReferenceExpression, expression Expression, inputTypes List<Type>) : AggregationBuilder in class com.facebook.presto.sql.planner.iterative.rule.test.PlanBuilder.AggregationBuilder | 
                                From | 
                                To | 
                            
                            
                            
                            
                            
                            
                            
                                 | 
                                Rename Variable	symbol : Symbol to variable : VariableReferenceExpression in method private createHashAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, globalGroupingSets Set<Integer>, groupbySymbols List<Symbol>, step Step, hashVariable Optional<VariableReferenceExpression>, groupIdSymbol Optional<Symbol>, source PhysicalOperation, hasDefaultOutput boolean, spillEnabled boolean, isStreamable boolean, unspillMemoryLimit DataSize, context LocalExecutionPlanContext, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, expectedGroups int, maxPartialAggregationMemorySize Optional<DataSize>, useSystemMemory boolean) : OperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	intermediateSymbol : Symbol to intermediateVariable : VariableReferenceExpression in method private split(node AggregationNode, context Context) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.PushPartialAggregationThroughExchange | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	coalesceSymbols : Map<Symbol,Symbol> to coalesceVariables : Map<VariableReferenceExpression,VariableReferenceExpression> in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	coalesceSymbolsBuilder : ImmutableMap.Builder<Symbol,Symbol> to coalesceVariablesBuilder : ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression> in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	newSymbol : Symbol to newVariable : VariableReferenceExpression in method private createNonDistinctAggregation(aggregateInfo AggregateInfo, distinctSymbol Symbol, duplicatedDistinctSymbol Symbol, groupByKeys Set<Symbol>, groupIdNode GroupIdNode, originalNode MarkDistinctNode, aggregationOutputSymbolsMapBuilder ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	symbol : Symbol to variable : VariableReferenceExpression in method public visitAggregation(node AggregationNode, context RewriteContext<Set<Symbol>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.PruneUnreferencedOutputs.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	newSymbol : Symbol to newVariable : VariableReferenceExpression in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	overNullSymbol : Symbol to overNull : VariableReferenceExpression in method private createAggregationOverNull(referenceAggregation AggregationNode, symbolAllocator SymbolAllocator, idAllocator PlanNodeIdAllocator, lookup Lookup) : Optional<MappedAggregationInfo> in class com.facebook.presto.sql.planner.iterative.rule.PushAggregationThroughOuterJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	countNullMatchesSymbol : Symbol to countNullMatchesVariable : VariableReferenceExpression in method private buildInPredicateEquivalent(apply ApplyNode, inPredicate InPredicate, inPredicateOutputSymbol Symbol, decorrelated Decorrelated, idAllocator PlanNodeIdAllocator, symbolAllocator SymbolAllocator) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.TransformCorrelatedInPredicateToJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	aggregationOutputSymbolsMap : Map<Symbol,Symbol> to aggregationOutputVariablesMap : Map<VariableReferenceExpression,VariableReferenceExpression> in method public visitMarkDistinct(node MarkDistinctNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	outputNonDistinctAggregateSymbols : ImmutableMap.Builder<Symbol,Symbol> to outputNonDistinctAggregateVariables : ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression> in method private createProjectNode(source AggregationNode, aggregateInfo AggregateInfo, distinctSymbol Symbol, groupSymbol Symbol, groupBySymbols List<Symbol>, aggregationOutputVariablesMap Map<VariableReferenceExpression,VariableReferenceExpression>) : ProjectNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	symbol : Symbol to variable : VariableReferenceExpression in method private createAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, step Step, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, source PhysicalOperation, context LocalExecutionPlanContext, useSystemMemory boolean) : AggregationOperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method public testInvalidAggregationFunctionCall() : void in class com.facebook.presto.sql.planner.TestTypeValidator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	newSymbol : Symbol to newVariable : VariableReferenceExpression in method private aggregate(subPlan PlanBuilder, node QuerySpecification) : PlanBuilder in class com.facebook.presto.sql.planner.QueryPlanner | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	aggregationOutputSymbolsMapBuilder : ImmutableMap.Builder<Symbol,Symbol> to aggregationOutputVariablesMapBuilder : ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression> in method public visitMarkDistinct(node MarkDistinctNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	symbol : Symbol to variable : VariableReferenceExpression in method private createAggregationNode(scalarAggregation AggregationNode, leftOuterJoin JoinNode, nonNullableAggregationSourceSymbol Symbol) : Optional<AggregationNode> in class com.facebook.presto.sql.planner.optimizations.ScalarAggregationToJoinRewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method public testValidAggregation() : void in class com.facebook.presto.sql.planner.TestTypeValidator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	symbol : Symbol to variable : VariableReferenceExpression in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.SimplifyCountOverConstant | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	newSymbol : Symbol to newVariable : VariableReferenceExpression in method private createProjectNode(source AggregationNode, aggregateInfo AggregateInfo, distinctSymbol Symbol, groupSymbol Symbol, groupBySymbols List<Symbol>, aggregationOutputVariablesMap Map<VariableReferenceExpression,VariableReferenceExpression>) : ProjectNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method private createAggregationOverNull(referenceAggregation AggregationNode, symbolAllocator SymbolAllocator, idAllocator PlanNodeIdAllocator, lookup Lookup) : Optional<MappedAggregationInfo> in class com.facebook.presto.sql.planner.iterative.rule.PushAggregationThroughOuterJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	countMatchesSymbol : Symbol to countMatchesVariable : VariableReferenceExpression in method private buildInPredicateEquivalent(apply ApplyNode, inPredicate InPredicate, inPredicateOutputSymbol Symbol, decorrelated Decorrelated, idAllocator PlanNodeIdAllocator, symbolAllocator SymbolAllocator) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.TransformCorrelatedInPredicateToJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	symbol : Symbol to variable : VariableReferenceExpression in method private addFilterForExcept(aggregation AggregationNode, firstSource VariableReferenceExpression, remainingSources List<VariableReferenceExpression>) : FilterNode in class com.facebook.presto.sql.planner.optimizations.ImplementIntersectAndExceptAsUnion.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method public testInvalidAggregationFunctionSignature() : void in class com.facebook.presto.sql.planner.TestTypeValidator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Rename Variable	symbol : Symbol to variable : VariableReferenceExpression in method public detailMatches(node PlanNode, stats StatsProvider, session Session, metadata Metadata, symbolAliases SymbolAliases) : MatchResult in class com.facebook.presto.sql.planner.assertions.AggregationMatcher | 
                                From | 
                                To | 
                            
                            
                            
                            
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public apply(node AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.RewriteSpatialPartitioningAggregation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	builder : ImmutableMap.Builder<Symbol,Aggregation> to builder : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method private inputsAsOutputs(assignments Map<VariableReferenceExpression,Aggregation>, types TypeProvider) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method public testInvalidAggregationFunctionCall() : void in class com.facebook.presto.sql.planner.TestTypeValidator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	assignment : Map.Entry<Symbol,Aggregation> to assignment : Map.Entry<VariableReferenceExpression,Aggregation> in method public getAssignedSymbol(node PlanNode, session Session, metadata Metadata, symbolAliases SymbolAliases) : Optional<Symbol> in class com.facebook.presto.sql.planner.assertions.AggregationFunctionMatcher | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationsBuilder : ImmutableMap.Builder<Symbol,Aggregation> to aggregationsBuilder : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method private aggregate(subPlan PlanBuilder, node QuerySpecification) : PlanBuilder in class com.facebook.presto.sql.planner.QueryPlanner | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method public apply(node AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.RewriteSpatialPartitioningAggregation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	avg : Symbol to avg : VariableReferenceExpression in method private buildAggregation(planBuilder PlanBuilder) : AggregationNode in class com.facebook.presto.sql.planner.iterative.rule.TestPruneOrderByInAggregation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	symbol : Symbol to variable : VariableReferenceExpression in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.SimplifyCountOverConstant | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method public testValidAggregation() : void in class com.facebook.presto.sql.planner.TestTypeValidator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,AggregationNode.Aggregation> to entry : Map.Entry<VariableReferenceExpression,AggregationNode.Aggregation> in method public visitAggregation(node AggregationNode, context Void) : Void in class com.facebook.presto.sql.planner.planPrinter.PlanPrinter.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	countAllValue : Symbol to countAllValue : VariableReferenceExpression in method private rewriteQuantifiedApplyNode(node ApplyNode, quantifiedComparison QuantifiedComparisonExpression, context RewriteContext<PlanNode>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.TransformQuantifiedComparisonApplyToLateralJoin.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private inputsAsOutputs(assignments Map<VariableReferenceExpression,Aggregation>, types TypeProvider) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	minValue : Symbol to minValue : VariableReferenceExpression in method private rewriteQuantifiedApplyNode(node ApplyNode, quantifiedComparison QuantifiedComparisonExpression, context RewriteContext<PlanNode>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.TransformQuantifiedComparisonApplyToLateralJoin.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	argument : Symbol to argument : VariableReferenceExpression in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	countMatchesSymbol : Symbol to countMatchesVariable : VariableReferenceExpression in method private buildInPredicateEquivalent(apply ApplyNode, inPredicate InPredicate, inPredicateOutputSymbol Symbol, decorrelated Decorrelated, idAllocator PlanNodeIdAllocator, symbolAllocator SymbolAllocator) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.TransformCorrelatedInPredicateToJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	output : Symbol to output : VariableReferenceExpression in method public apply(aggregation AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.ImplementFilteredAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	newSymbol : Symbol to newVariable : VariableReferenceExpression in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	overNullSymbol : Symbol to overNull : VariableReferenceExpression in method private createAggregationOverNull(referenceAggregation AggregationNode, symbolAllocator SymbolAllocator, idAllocator PlanNodeIdAllocator, lookup Lookup) : Optional<MappedAggregationInfo> in class com.facebook.presto.sql.planner.iterative.rule.PushAggregationThroughOuterJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public visitAggregation(node AggregationNode, context RewriteContext<Set<Symbol>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.PruneUnreferencedOutputs.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	finalAggregation : Map<Symbol,AggregationNode.Aggregation> to finalAggregation : Map<VariableReferenceExpression,AggregationNode.Aggregation> in method private split(node AggregationNode, context Context) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.PushPartialAggregationThroughExchange | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationOutputSymbols : List<Symbol> to aggregationOutputSymbols : List<VariableReferenceExpression> in method private createHashAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, globalGroupingSets Set<Integer>, groupbySymbols List<Symbol>, step Step, hashVariable Optional<VariableReferenceExpression>, groupIdSymbol Optional<Symbol>, source PhysicalOperation, hasDefaultOutput boolean, spillEnabled boolean, isStreamable boolean, unspillMemoryLimit DataSize, context LocalExecutionPlanContext, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, expectedGroups int, maxPartialAggregationMemorySize Optional<DataSize>, useSystemMemory boolean) : OperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	output : Symbol to output : VariableReferenceExpression in method private outputsAsInputs(assignments Map<VariableReferenceExpression,Aggregation>) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	intermediateSymbol : Symbol to intermediateVariable : VariableReferenceExpression in method private split(node AggregationNode, context Context) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.PushPartialAggregationThroughExchange | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	coalesceSymbols : Map<Symbol,Symbol> to coalesceVariables : Map<VariableReferenceExpression,VariableReferenceExpression> in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private createAggregationNode(scalarAggregation AggregationNode, leftOuterJoin JoinNode, nonNullableAggregationSourceSymbol Symbol) : Optional<AggregationNode> in class com.facebook.presto.sql.planner.optimizations.ScalarAggregationToJoinRewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	countNonNullValue : Symbol to countNonNullValue : VariableReferenceExpression in method private rewriteQuantifiedApplyNode(node ApplyNode, quantifiedComparison QuantifiedComparisonExpression, context RewriteContext<PlanNode>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.TransformQuantifiedComparisonApplyToLateralJoin.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method public apply(node AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.PruneOrderByInAggregation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method public visitAggregation(node AggregationNode, context RewriteContext<Set<Symbol>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.PruneUnreferencedOutputs.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	coalesceSymbolsBuilder : ImmutableMap.Builder<Symbol,Symbol> to coalesceVariablesBuilder : ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression> in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public apply(aggregation AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.ImplementFilteredAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	newSymbol : Symbol to newVariable : VariableReferenceExpression in method private createNonDistinctAggregation(aggregateInfo AggregateInfo, distinctSymbol Symbol, duplicatedDistinctSymbol Symbol, groupByKeys Set<Symbol>, groupIdNode GroupIdNode, originalNode MarkDistinctNode, aggregationOutputSymbolsMapBuilder ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,AggregationNode.Aggregation> to entry : Map.Entry<VariableReferenceExpression,AggregationNode.Aggregation> in method private createAggregationOverNull(referenceAggregation AggregationNode, symbolAllocator SymbolAllocator, idAllocator PlanNodeIdAllocator, lookup Lookup) : Optional<MappedAggregationInfo> in class com.facebook.presto.sql.planner.iterative.rule.PushAggregationThroughOuterJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Entry<Symbol,Aggregation> to entry : Entry<VariableReferenceExpression,Aggregation> in method private map(node AggregationNode, source PlanNode, newNodeId PlanNodeId) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.SymbolMapper | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private createNonDistinctAggregation(aggregateInfo AggregateInfo, distinctSymbol Symbol, duplicatedDistinctSymbol Symbol, groupByKeys Set<Symbol>, groupIdNode GroupIdNode, originalNode MarkDistinctNode, aggregationOutputSymbolsMapBuilder ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	assignments : Map<Symbol,AggregationNode.Aggregation> to assignments : Map<VariableReferenceExpression,AggregationNode.Aggregation> in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.PruneCountAggregationOverScalar | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	countNullMatchesSymbol : Symbol to countNullMatchesVariable : VariableReferenceExpression in method private buildInPredicateEquivalent(apply ApplyNode, inPredicate InPredicate, inPredicateOutputSymbol Symbol, decorrelated Decorrelated, idAllocator PlanNodeIdAllocator, symbolAllocator SymbolAllocator) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.TransformCorrelatedInPredicateToJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationOutputSymbolsMap : Map<Symbol,Symbol> to aggregationOutputVariablesMap : Map<VariableReferenceExpression,VariableReferenceExpression> in method public visitMarkDistinct(node MarkDistinctNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method private map(node AggregationNode, source PlanNode, newNodeId PlanNodeId) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.SymbolMapper | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method public testInvalidAggregationFunctionSignature() : void in class com.facebook.presto.sql.planner.TestTypeValidator | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : Map<Symbol,Aggregation> to aggregations : Map<VariableReferenceExpression,Aggregation> in method private aggregate(subPlan PlanBuilder, node QuerySpecification) : PlanBuilder in class com.facebook.presto.sql.planner.QueryPlanner | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method private createAggregationNode(scalarAggregation AggregationNode, leftOuterJoin JoinNode, nonNullableAggregationSourceSymbol Symbol) : Optional<AggregationNode> in class com.facebook.presto.sql.planner.optimizations.ScalarAggregationToJoinRewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	newAggregations : Map<Symbol,Aggregation> to newAggregations : Map<VariableReferenceExpression,Aggregation> in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.MultipleDistinctAggregationToMarkDistinct | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	count : Symbol to count : VariableReferenceExpression in method private rewriteToDefaultAggregation(parent ApplyNode, context Context) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.TransformExistsApplyToLateralNode | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public visitAggregation(node AggregationNode, context Void) : Void in class com.facebook.presto.util.GraphvizPrinter.NodePrinter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method public visitAggregation(node AggregationNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	newSymbol : Symbol to newVariable : VariableReferenceExpression in method private aggregate(subPlan PlanBuilder, node QuerySpecification) : PlanBuilder in class com.facebook.presto.sql.planner.QueryPlanner | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationOutputSymbolsMapBuilder : ImmutableMap.Builder<Symbol,Symbol> to aggregationOutputVariablesMapBuilder : ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression> in method public visitMarkDistinct(node MarkDistinctNode, context RewriteContext<Optional<AggregateInfo>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationsWithMask : List<Symbol> to aggregationsWithMask : List<VariableReferenceExpression> in method public detailMatches(node PlanNode, stats StatsProvider, session Session, metadata Metadata, symbolAliases SymbolAliases) : MatchResult in class com.facebook.presto.sql.planner.assertions.AggregationMatcher | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	symbol : Symbol to variable : VariableReferenceExpression in method private createHashAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, globalGroupingSets Set<Integer>, groupbySymbols List<Symbol>, step Step, hashVariable Optional<VariableReferenceExpression>, groupIdSymbol Optional<Symbol>, source PhysicalOperation, hasDefaultOutput boolean, spillEnabled boolean, isStreamable boolean, unspillMemoryLimit DataSize, context LocalExecutionPlanContext, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, expectedGroups int, maxPartialAggregationMemorySize Optional<DataSize>, useSystemMemory boolean) : OperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	output : Symbol to output : VariableReferenceExpression in method private computeCounts(sourceNode UnionNode, originalColumns List<Symbol>, markers List<VariableReferenceExpression>, aggregationOutputs List<VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.ImplementIntersectAndExceptAsUnion.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	input : Symbol to input : VariableReferenceExpression in method private inputsAsOutputs(assignments Map<VariableReferenceExpression,Aggregation>, types TypeProvider) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private createAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, step Step, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, source PhysicalOperation, context LocalExecutionPlanContext, useSystemMemory boolean) : AggregationOperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : Map<Symbol,AggregationNode.Aggregation> to aggregations : Map<VariableReferenceExpression,AggregationNode.Aggregation> in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.SimplifyCountOverConstant | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private createHashAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, globalGroupingSets Set<Integer>, groupbySymbols List<Symbol>, step Step, hashVariable Optional<VariableReferenceExpression>, groupIdSymbol Optional<Symbol>, source PhysicalOperation, hasDefaultOutput boolean, spillEnabled boolean, isStreamable boolean, unspillMemoryLimit DataSize, context LocalExecutionPlanContext, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, expectedGroups int, maxPartialAggregationMemorySize Optional<DataSize>, useSystemMemory boolean) : OperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	arrayAgg : Symbol to arrayAgg : VariableReferenceExpression in method private buildAggregation(planBuilder PlanBuilder) : AggregationNode in class com.facebook.presto.sql.planner.iterative.rule.TestPruneOrderByInAggregation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	newSymbol : Symbol to newVariable : VariableReferenceExpression in method private createProjectNode(source AggregationNode, aggregateInfo AggregateInfo, distinctSymbol Symbol, groupSymbol Symbol, groupBySymbols List<Symbol>, aggregationOutputVariablesMap Map<VariableReferenceExpression,VariableReferenceExpression>) : ProjectNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	symbol : Symbol to variable : VariableReferenceExpression in method public visitAggregation(node AggregationNode, context RewriteContext<Set<Symbol>>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.PruneUnreferencedOutputs.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	avg : Symbol to avg : VariableReferenceExpression in method private buildAggregation(planBuilder PlanBuilder, sourceSymbolFilter Predicate<Symbol>) : AggregationNode in class com.facebook.presto.sql.planner.iterative.rule.TestPruneAggregationSourceColumns | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,AggregationNode.Aggregation> to entry : Map.Entry<VariableReferenceExpression,AggregationNode.Aggregation> in method private split(node AggregationNode, context Context) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.PushPartialAggregationThroughExchange | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private checkAggregation(aggregations Map<VariableReferenceExpression,Aggregation>) : void in class com.facebook.presto.sql.planner.sanity.TypeValidator.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method private computeCounts(sourceNode UnionNode, originalColumns List<Symbol>, markers List<VariableReferenceExpression>, aggregationOutputs List<VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.ImplementIntersectAndExceptAsUnion.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	outputNonDistinctAggregateSymbols : ImmutableMap.Builder<Symbol,Symbol> to outputNonDistinctAggregateVariables : ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression> in method private createProjectNode(source AggregationNode, aggregateInfo AggregateInfo, distinctSymbol Symbol, groupSymbol Symbol, groupBySymbols List<Symbol>, aggregationOutputVariablesMap Map<VariableReferenceExpression,VariableReferenceExpression>) : ProjectNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Entry<Symbol,AggregationNode.Aggregation> to entry : Entry<VariableReferenceExpression,AggregationNode.Aggregation> in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.SimplifyCountOverConstant | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	maxValue : Symbol to maxValue : VariableReferenceExpression in method private rewriteQuantifiedApplyNode(node ApplyNode, quantifiedComparison QuantifiedComparisonExpression, context RewriteContext<PlanNode>) : PlanNode in class com.facebook.presto.sql.planner.optimizations.TransformQuantifiedComparisonApplyToLateralJoin.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationsOverNullBuilder : ImmutableMap.Builder<Symbol,AggregationNode.Aggregation> to aggregationsOverNullBuilder : ImmutableMap.Builder<VariableReferenceExpression,AggregationNode.Aggregation> in method private createAggregationOverNull(referenceAggregation AggregationNode, symbolAllocator SymbolAllocator, idAllocator PlanNodeIdAllocator, lookup Lookup) : Optional<MappedAggregationInfo> in class com.facebook.presto.sql.planner.iterative.rule.PushAggregationThroughOuterJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	symbol : Symbol to variable : VariableReferenceExpression in method private createAggregationOperatorFactory(planNodeId PlanNodeId, aggregations Map<VariableReferenceExpression,Aggregation>, step Step, startOutputChannel int, outputMappings ImmutableMap.Builder<Symbol,Integer>, source PhysicalOperation, context LocalExecutionPlanContext, useSystemMemory boolean) : AggregationOperatorFactory in class com.facebook.presto.sql.planner.LocalExecutionPlanner.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private checkFunctionSignature(aggregations Map<VariableReferenceExpression,Aggregation>) : void in class com.facebook.presto.sql.planner.sanity.TypeValidator.Visitor | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	symbol : Symbol to variable : VariableReferenceExpression in method private createAggregationNode(scalarAggregation AggregationNode, leftOuterJoin JoinNode, nonNullableAggregationSourceSymbol Symbol) : Optional<AggregationNode> in class com.facebook.presto.sql.planner.optimizations.ScalarAggregationToJoinRewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.MultipleDistinctAggregationToMarkDistinct | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method public apply(aggregation AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.ImplementFilteredAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public apply(node AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.PruneOrderByInAggregation | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregationSymbol : Symbol to aggregationVariable : VariableReferenceExpression in method private createAggregationOverNull(referenceAggregation AggregationNode, symbolAllocator SymbolAllocator, idAllocator PlanNodeIdAllocator, lookup Lookup) : Optional<MappedAggregationInfo> in class com.facebook.presto.sql.planner.iterative.rule.PushAggregationThroughOuterJoin | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	builder : ImmutableMap.Builder<Symbol,Aggregation> to builder : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method private outputsAsInputs(assignments Map<VariableReferenceExpression,Aggregation>) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method public apply(aggregationNode AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.ExpressionRewriteRuleSet.AggregationExpressionRewrite | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,AggregationNode.Aggregation> to entry : Map.Entry<VariableReferenceExpression,AggregationNode.Aggregation> in method public apply(parent AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.PruneCountAggregationOverScalar | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	symbol : Symbol to variable : VariableReferenceExpression in method private addFilterForExcept(aggregation AggregationNode, firstSource VariableReferenceExpression, remainingSources List<VariableReferenceExpression>) : FilterNode in class com.facebook.presto.sql.planner.optimizations.ImplementIntersectAndExceptAsUnion.Rewriter | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	aggregations : ImmutableMap.Builder<Symbol,Aggregation> to aggregations : ImmutableMap.Builder<VariableReferenceExpression,Aggregation> in method private createNonDistinctAggregation(aggregateInfo AggregateInfo, distinctSymbol Symbol, duplicatedDistinctSymbol Symbol, groupByKeys Set<Symbol>, groupIdNode GroupIdNode, originalNode MarkDistinctNode, aggregationOutputSymbolsMapBuilder ImmutableMap.Builder<VariableReferenceExpression,VariableReferenceExpression>) : AggregationNode in class com.facebook.presto.sql.planner.optimizations.OptimizeMixedDistinctAggregations.Optimizer | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	symbol : Symbol to variable : VariableReferenceExpression in method public detailMatches(node PlanNode, stats StatsProvider, session Session, metadata Metadata, symbolAliases SymbolAliases) : MatchResult in class com.facebook.presto.sql.planner.assertions.AggregationMatcher | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	intermediateAggregation : Map<Symbol,AggregationNode.Aggregation> to intermediateAggregation : Map<VariableReferenceExpression,AggregationNode.Aggregation> in method private split(node AggregationNode, context Context) : PlanNode in class com.facebook.presto.sql.planner.iterative.rule.PushPartialAggregationThroughExchange | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method public apply(aggregationNode AggregationNode, captures Captures, context Context) : Result in class com.facebook.presto.sql.planner.iterative.rule.ExpressionRewriteRuleSet.AggregationExpressionRewrite | 
                                From | 
                                To | 
                            
                            
                            
                                 | 
                                Change Variable Type	entry : Map.Entry<Symbol,Aggregation> to entry : Map.Entry<VariableReferenceExpression,Aggregation> in method private outputsAsInputs(assignments Map<VariableReferenceExpression,Aggregation>) : Map<VariableReferenceExpression,Aggregation> in class com.facebook.presto.sql.planner.iterative.rule.AddIntermediateAggregations | 
                                From | 
                                To |