diff --git a/apps/regression/regression_context.cpp b/apps/regression/regression_context.cpp
index 1550cd2bc..87e5d61fb 100644
--- a/apps/regression/regression_context.cpp
+++ b/apps/regression/regression_context.cpp
@@ -9,7 +9,7 @@ using namespace Shared;
 
 namespace Regression {
 
-const Expression RegressionContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
+const Expression RegressionContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
   if (symbol.type() == ExpressionNode::Type::Symbol && Symbol::isRegressionSymbol(symbol.name())) {
     const char * seriesName = symbol.name();
     assert(strlen(seriesName) == 2);
@@ -24,7 +24,7 @@ const Expression RegressionContext::expressionForSymbol(const SymbolAbstract & s
     assert(m_seriesPairIndex < m_store->numberOfPairsOfSeries(series));
     return Float<double>::Builder(m_store->get(series, storeI, m_seriesPairIndex));
   } else {
-    return m_parentContext->expressionForSymbol(symbol, clone);
+    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
   }
 }
 
diff --git a/apps/regression/regression_context.h b/apps/regression/regression_context.h
index d2c92ef5d..c9e5fe8dd 100644
--- a/apps/regression/regression_context.h
+++ b/apps/regression/regression_context.h
@@ -9,7 +9,7 @@ namespace Regression {
 class RegressionContext : public Shared::StoreContext {
 public:
   using Shared::StoreContext::StoreContext;
-  const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
+  const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
 };
 
 }
diff --git a/apps/sequence/cache_context.cpp b/apps/sequence/cache_context.cpp
index f838d0610..6b438882a 100644
--- a/apps/sequence/cache_context.cpp
+++ b/apps/sequence/cache_context.cpp
@@ -14,7 +14,7 @@ CacheContext<T>::CacheContext(Context * parentContext) :
 }
 
 template<typename T>
-const Expression CacheContext<T>::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
+const Expression CacheContext<T>::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
   // [u|v|w](n(+1)?)
   if (symbol.type() == ExpressionNode::Type::Symbol
     && symbol.name()[0] >= SequenceStore::k_sequenceNames[0][0]
@@ -24,12 +24,12 @@ const Expression CacheContext<T>::expressionForSymbol(const SymbolAbstract & sym
     Symbol s = const_cast<Symbol &>(static_cast<const Symbol &>(symbol));
     return Float<T>::Builder(m_values[nameIndexForSymbol(s)][rankIndexForSymbol(s)]);
   }
-  return m_parentContext->expressionForSymbol(symbol, clone);
+  return m_parentContext->expressionForSymbolAbstract(symbol, clone);
 }
 
 template<typename T>
-void CacheContext<T>::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
-  m_parentContext->setExpressionForSymbol(expression, symbol, context);
+void CacheContext<T>::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
+  m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
 }
 
 template<typename T>
diff --git a/apps/sequence/cache_context.h b/apps/sequence/cache_context.h
index 90e69c52c..85696dc36 100644
--- a/apps/sequence/cache_context.h
+++ b/apps/sequence/cache_context.h
@@ -12,8 +12,8 @@ template<typename T>
 class CacheContext : public Poincare::Context {
 public:
   CacheContext(Poincare::Context * parentContext);
-  const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
-  void setExpressionForSymbol(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
+  const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
+  void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
   void setValueForSymbol(T value, const Poincare::Symbol & symbol);
 private:
   int nameIndexForSymbol(const Poincare::Symbol & symbol);
diff --git a/apps/sequence/sequence_context.h b/apps/sequence/sequence_context.h
index 86088840f..7be29efe5 100644
--- a/apps/sequence/sequence_context.h
+++ b/apps/sequence/sequence_context.h
@@ -41,15 +41,15 @@ public:
     m_doubleSequenceContext(),
     m_sequenceStore(sequenceStore),
     m_parentContext(parentContext) {}
-  /* expressionForSymbol & setExpressionForSymbolName directly call the parent
+  /* expressionForSymbolAbstract & setExpressionForSymbolAbstractName directly call the parent
    * context respective methods. Indeed, special chars like n, u(n), u(n+1),
    * v(n), v(n+1) are taken into accound only when evaluating sequences which
    * is done in another context. */
-  const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override {
-    return m_parentContext->expressionForSymbol(symbol, clone);
+  const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override {
+    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
   }
-  void setExpressionForSymbol(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override {
-    m_parentContext->setExpressionForSymbol(expression, symbol, context);
+  void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override {
+    m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
   }
   template<typename T> T valueOfSequenceAtPreviousRank(int sequenceIndex, int rank) const {
     if (sizeof(T) == sizeof(float)) {
diff --git a/apps/shared/global_context.cpp b/apps/shared/global_context.cpp
index b77075ac0..894478456 100644
--- a/apps/shared/global_context.cpp
+++ b/apps/shared/global_context.cpp
@@ -57,12 +57,12 @@ void GlobalContext::DestroyRecordsBaseNamedWithoutExtension(const char * baseNam
   }
 }
 
-const Expression GlobalContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
+const Expression GlobalContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
   Ion::Storage::Record r = SymbolAbstractRecordWithBaseName(symbol.name());
   return ExpressionForSymbolAndRecord(symbol, r);
 }
 
-void GlobalContext::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
+void GlobalContext::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
   /* If the new expression contains the symbol, replace it because it will be
    * destroyed afterwards (to be able to do A+2->A) */
   Ion::Storage::Record record = SymbolAbstractRecordWithBaseName(symbol.name());
diff --git a/apps/shared/global_context.h b/apps/shared/global_context.h
index 45ad9f49f..9735a5d4f 100644
--- a/apps/shared/global_context.h
+++ b/apps/shared/global_context.h
@@ -33,8 +33,8 @@ public:
   /* Expression for symbol
    * The expression recorded in global context is already an expression.
    * Otherwise, we would need the context and the angle unit to evaluate it */
-  const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
-  void setExpressionForSymbol(
+  const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
+  void setExpressionForSymbolAbstract(
       const Poincare::Expression & expression,
       const Poincare::SymbolAbstract & symbol,
       Poincare::Context * context) override;
diff --git a/apps/shared/store_context.cpp b/apps/shared/store_context.cpp
index 967d5d132..321522fc3 100644
--- a/apps/shared/store_context.cpp
+++ b/apps/shared/store_context.cpp
@@ -7,8 +7,8 @@ using namespace Poincare;
 
 namespace Shared {
 
-void StoreContext::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
-  m_parentContext->setExpressionForSymbol(expression, symbol, context);
+void StoreContext::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
+  m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
 }
 
 }
diff --git a/apps/shared/store_context.h b/apps/shared/store_context.h
index f200add13..f1a8acd37 100644
--- a/apps/shared/store_context.h
+++ b/apps/shared/store_context.h
@@ -19,7 +19,7 @@ public:
   {}
   void setParentContext(Poincare::Context * parentContext) { m_parentContext = parentContext; }
   void setSeriesPairIndex(int j) { m_seriesPairIndex = j; }
-  void setExpressionForSymbol(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
+  void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
 protected:
   Shared::DoublePairStore * m_store;
   int m_seriesPairIndex;
diff --git a/apps/statistics/statistics_context.cpp b/apps/statistics/statistics_context.cpp
index 23830d431..744a06b4d 100644
--- a/apps/statistics/statistics_context.cpp
+++ b/apps/statistics/statistics_context.cpp
@@ -9,7 +9,7 @@ using namespace Shared;
 
 namespace Statistics {
 
-const Expression StatisticsContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
+const Expression StatisticsContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
   if (symbol.type() == ExpressionNode::Type::Symbol && Symbol::isSeriesSymbol(symbol.name())) {
     const char * seriesName = symbol.name();
     assert(strlen(seriesName) == 2);
@@ -24,7 +24,7 @@ const Expression StatisticsContext::expressionForSymbol(const SymbolAbstract & s
     assert(m_seriesPairIndex < m_store->numberOfPairsOfSeries(series));
     return Float<double>::Builder(m_store->get(series, storeI, m_seriesPairIndex));
   } else {
-    return m_parentContext->expressionForSymbol(symbol, clone);
+    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
   }
 }
 
diff --git a/apps/statistics/statistics_context.h b/apps/statistics/statistics_context.h
index 833dff458..2ca69c089 100644
--- a/apps/statistics/statistics_context.h
+++ b/apps/statistics/statistics_context.h
@@ -8,7 +8,7 @@ namespace Statistics {
 class StatisticsContext : public Shared::StoreContext {
 public:
   using Shared::StoreContext::StoreContext;
-  const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
+  const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
 };
 
 }
diff --git a/poincare/include/poincare/context.h b/poincare/include/poincare/context.h
index 4d4700908..23189d0aa 100644
--- a/poincare/include/poincare/context.h
+++ b/poincare/include/poincare/context.h
@@ -8,8 +8,8 @@ class SymbolAbstract;
 
 class Context {
 public:
-  virtual const Expression expressionForSymbol(const SymbolAbstract & symbol, bool clone) = 0;
-  virtual void setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) = 0;
+  virtual const Expression expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) = 0;
+  virtual void setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) = 0;
 };
 
 }
diff --git a/poincare/include/poincare/variable_context.h b/poincare/include/poincare/variable_context.h
index 1df5d850c..5f52c7af3 100644
--- a/poincare/include/poincare/variable_context.h
+++ b/poincare/include/poincare/variable_context.h
@@ -13,8 +13,8 @@ public:
   void setApproximationForVariable(T value);
 
   // Context
-  void setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) override;
-  const Expression expressionForSymbol(const SymbolAbstract & symbol, bool clone) override;
+  void setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) override;
+  const Expression expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) override;
 
 private:
   const char * m_name;
diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp
index 5cc99f2f3..dbdd4cc6c 100644
--- a/poincare/src/expression.cpp
+++ b/poincare/src/expression.cpp
@@ -320,9 +320,9 @@ bool Expression::hasReplaceableSymbols(Context * context) const {
   return recursivelyMatches([](const Expression e, Context * context) {
       return (e.type() == ExpressionNode::Type::Symbol
           && !static_cast<const Symbol &>(e).isSystemSymbol()
-          && !context->expressionForSymbol(static_cast<const Symbol &>(e), false).isUninitialized())
+          && !context->expressionForSymbolAbstract(static_cast<const Symbol &>(e), false).isUninitialized())
       || (e.type() == ExpressionNode::Type::Function
-           && !context->expressionForSymbol(static_cast<const Function &>(e), false).isUninitialized());
+           && !context->expressionForSymbolAbstract(static_cast<const Function &>(e), false).isUninitialized());
       }, context, false);
 }
 
diff --git a/poincare/src/function.cpp b/poincare/src/function.cpp
index ea8ca7c38..4393a8301 100644
--- a/poincare/src/function.cpp
+++ b/poincare/src/function.cpp
@@ -129,7 +129,7 @@ Expression Function::shallowReduce(ExpressionNode::ReductionContext reductionCon
 }
 
 Expression Function::shallowReplaceReplaceableSymbols(Context * context) {
-  Expression e = context->expressionForSymbol(*this, true);
+  Expression e = context->expressionForSymbolAbstract(*this, true);
   if (e.isUninitialized()) {
     return *this;
   }
@@ -154,7 +154,7 @@ VariableContext Function::unknownXContext(Context & parentContext) const {
   /* If the parentContext already has an expression for UnknownX, we have to
    * replace in childAtIndex(0) any occurence of UnknownX by its value in
    * parentContext. That way, we handle: evaluatin f(x-1) with x = 2 & f:x->x^2 */
-  Expression unknownXValue = parentContext.expressionForSymbol(unknownXSymbol, true);
+  Expression unknownXValue = parentContext.expressionForSymbolAbstract(unknownXSymbol, true);
   if (!unknownXValue.isUninitialized()) {
     xContext = static_cast<VariableContext &>(parentContext); // copy the parentContext
     child.replaceSymbolWithExpression(unknownXSymbol, unknownXValue);
@@ -164,7 +164,7 @@ VariableContext Function::unknownXContext(Context & parentContext) const {
   assert(!child.recursivelyMatches([](const Expression e, Context * context, bool replaceSymbol) {
         return e.type() == ExpressionNode::Type::Symbol && static_cast<const Symbol &>(e).isSystemSymbol();
       }, parentContext, false));
-  xContext.setExpressionForSymbol(child, unknownXSymbol, xContext);
+  xContext.setExpressionForSymbolAbstract(child, unknownXSymbol, xContext);
   return xContext;
 }
 #endif
diff --git a/poincare/src/store.cpp b/poincare/src/store.cpp
index 8a7280036..5cf9cb8b7 100644
--- a/poincare/src/store.cpp
+++ b/poincare/src/store.cpp
@@ -38,7 +38,7 @@ template<typename T>
 Evaluation<T> StoreNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
   /* If we are here, it means that the store node was not shallowReduced.
    * Otherwise, it would have been replaced by its symbol. We thus have to
-   * setExpressionForSymbol. */
+   * setExpressionForSymbolAbstract. */
   Expression storedExpression = Store(this).storeValueForSymbol(context, complexFormat, angleUnit);
   assert(!storedExpression.isUninitialized());
   return storedExpression.node()->approximate(T(), context, complexFormat, angleUnit);
@@ -80,8 +80,8 @@ Expression Store::storeValueForSymbol(Context * context, Preferences::ComplexFor
     finalValue = childAtIndex(0);
   }
   assert(!finalValue.isUninitialized());
-  context->setExpressionForSymbol(finalValue, symbol(), context);
-  Expression storedExpression = context->expressionForSymbol(symbol(), true);
+  context->setExpressionForSymbolAbstract(finalValue, symbol(), context);
+  Expression storedExpression = context->expressionForSymbolAbstract(symbol(), true);
 
   if (storedExpression.isUninitialized()) {
     return Undefined::Builder();
diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp
index c9dba106c..337efc402 100644
--- a/poincare/src/symbol.cpp
+++ b/poincare/src/symbol.cpp
@@ -235,7 +235,7 @@ Expression Symbol::shallowReplaceReplaceableSymbols(Context * context) {
   if (isSystemSymbol()) {
     return *this;
   }
-  Expression e = context->expressionForSymbol(*this, true);
+  Expression e = context->expressionForSymbolAbstract(*this, true);
   if (e.isUninitialized()) {
     return *this;
   }
diff --git a/poincare/src/symbol_abstract.cpp b/poincare/src/symbol_abstract.cpp
index 91f137644..829232870 100644
--- a/poincare/src/symbol_abstract.cpp
+++ b/poincare/src/symbol_abstract.cpp
@@ -60,7 +60,7 @@ Expression SymbolAbstract::Expand(const SymbolAbstract & symbol, Context * conte
   bool isFunction = symbol.type() == ExpressionNode::Type::Function;
   /* Always clone the expression for Function because we are going to alter e
    * by replacing all UnknownX in it. */
-  Expression e = context->expressionForSymbol(symbol, clone || isFunction);
+  Expression e = context->expressionForSymbolAbstract(symbol, clone || isFunction);
   /* Replace all the symbols iteratively. This prevents a memory failure when
    * symbols are defined circularly. */
   e = Expression::ExpressionWithoutSymbols(e, context);
diff --git a/poincare/src/variable_context.cpp b/poincare/src/variable_context.cpp
index ac16b2049..be72a510b 100644
--- a/poincare/src/variable_context.cpp
+++ b/poincare/src/variable_context.cpp
@@ -18,22 +18,22 @@ void VariableContext::setApproximationForVariable(T value) {
   m_value = Float<T>::Builder(value);
 }
 
-void VariableContext::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
+void VariableContext::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
   if (strcmp(symbol.name(), m_name) == 0) {
     if (expression.isUninitialized()) {
       return;
     }
     m_value = expression.clone();
   } else {
-    m_parentContext->setExpressionForSymbol(expression, symbol, context);
+    m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
   }
 }
 
-const Expression VariableContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
+const Expression VariableContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
   if (strcmp(symbol.name(), m_name) == 0) {
     return clone ? m_value.clone() : m_value;
   } else {
-    return m_parentContext->expressionForSymbol(symbol, clone);
+    return m_parentContext->expressionForSymbolAbstract(symbol, clone);
   }
 }