From af2c95be26e4e243eba17e4c0e93bd58faef943b Mon Sep 17 00:00:00 2001
From: Ruben Dashyan <ruben.dashyan@numworks.com>
Date: Fri, 13 Sep 2019 16:09:50 +0200
Subject: [PATCH] [poincare/parametered_expression] Turn replaceUnknown into
 replaceSymbolWithExpression

That is the only place where those methods did differ.
---
 .../include/poincare/parametered_expression.h |  4 ++--
 poincare/src/parametered_expression.cpp       | 19 ++++++++++---------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/poincare/include/poincare/parametered_expression.h b/poincare/include/poincare/parametered_expression.h
index d91c96cb7..991276d65 100644
--- a/poincare/include/poincare/parametered_expression.h
+++ b/poincare/include/poincare/parametered_expression.h
@@ -13,7 +13,7 @@ class ParameteredExpressionNode : public ExpressionNode {
 public:
   // Expression
   bool isParameteredExpression() const override { return true; }
-  Expression replaceUnknown(const Symbol & symbol, const Symbol & unknownSymbol) override;
+  Expression replaceSymbolWithExpression(const SymbolAbstract & symbol, const Expression & expression) override;
 };
 
 class ParameteredExpression : public Expression {
@@ -33,7 +33,7 @@ public:
    * unknowns: for instance, we want to change f(x)=diff(cos(x),x,x) into
    * f(X)=diff(cos(x),x,X), X being an unknown. ReplaceUnknownInExpression does
    * that. */
-  Expression replaceUnknown(const Symbol & symbol, const Symbol & unknownSymbol);
+  Expression replaceSymbolWithExpression(const SymbolAbstract & symbol, const Expression & expression);
 protected:
   ParameteredExpression(const ParameteredExpressionNode * node) : Expression(node) {}
 };
diff --git a/poincare/src/parametered_expression.cpp b/poincare/src/parametered_expression.cpp
index 5d533b39f..488b5acb9 100644
--- a/poincare/src/parametered_expression.cpp
+++ b/poincare/src/parametered_expression.cpp
@@ -5,26 +5,27 @@
 
 namespace Poincare {
 
-Expression ParameteredExpressionNode::replaceUnknown(const Symbol & symbol, const Symbol & unknownSymbol) {
-  return ParameteredExpression(this).replaceUnknown(symbol, unknownSymbol);
+Expression ParameteredExpressionNode::replaceSymbolWithExpression(const SymbolAbstract & symbol, const Expression & expression) {
+  return ParameteredExpression(this).replaceSymbolWithExpression(symbol, expression);
 }
 
-Expression ParameteredExpression::replaceUnknown(const Symbol & symbolToReplace, const Symbol & unknownSymbol) {
+Expression ParameteredExpression::replaceSymbolWithExpression(const SymbolAbstract & symbol, const Expression & expression) {
   Expression c = childAtIndex(ParameterChildIndex());
   assert(c.type() == ExpressionNode::Type::Symbol);
   Symbol& parameterChild = static_cast<Symbol &>(c);
-  if (strcmp(parameterChild.name(), symbolToReplace.name()) != 0) {
-    // If the unknown is not the parameter, replace normally
-    return defaultReplaceSymbolWithExpression(symbolToReplace, unknownSymbol);
+  if (symbol.type() != ExpressionNode::Type::Symbol ||
+      strcmp(symbol.name(), parameterChild.name()) != 0) {
+    // If the symbol is not the parameter, replace normally
+    return defaultReplaceSymbolWithExpression(symbol, expression);
   }
 
-  /* If the unknown is the parameter, replace the unknown in all children except
+  /* If the symbol is the parameter, replace it in all children except
    * in the parameter and the parametered children */
   int childrenCount = numberOfChildren();
   static_assert(ParameteredChildIndex() == 0 && ParameterChildIndex() == 1,
-      "ParameteredExpression::replaceUnknown might not be valid");
+      "ParameteredExpression::replaceSymbolWithExpression might not be valid");
   for (int i = 2; i < childrenCount; i++) {
-    childAtIndex(i).replaceUnknown(symbolToReplace, unknownSymbol);
+    childAtIndex(i).replaceSymbolWithExpression(symbol, expression);
   }
   return *this;
 }