Avoid duplicate code

Author: amanomer

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala

@@ -573,7 +573,7 @@ object FunctionRegistry {
   val functionSet: Set[FunctionIdentifier] = builtin.listFunction().toSet
 
   /** See usage above. */
-  private def expression[T <: Expression](name: String)
+  private def expression[T <: Expression](name: String, isAliasName: Boolean = false)
       (implicit tag: ClassTag[T]): (String, (ExpressionInfo, FunctionBuilder)) = {
 
     // For `RuntimeReplaceable`, skip the constructor with most arguments, which is the main
@@ -619,7 +619,9 @@ object FunctionRegistry {
           throw new AnalysisException(invalidArgumentsMsg)
         }
         try {
-          f.newInstance(expressions : _*).asInstanceOf[Expression]
+          val exp = f.newInstance(expressions : _*).asInstanceOf[Expression]
+          if (isAliasName) exp.setTagValue(exp.FUNC_ALIAS, name)
+          exp
         } catch {
           // the exception is an invocation exception. To get a meaningful message, we need the
           // cause.
@@ -633,62 +635,7 @@ object FunctionRegistry {
 
   private def expressionWithAlias[T <: Expression](name: String)
       (implicit tag: ClassTag[T]): (String, (ExpressionInfo, FunctionBuilder)) = {
-
-    // For `RuntimeReplaceable`, skip the constructor with most arguments, which is the main
-    // constructor and contains non-parameter `child` and should not be used as function builder.
-    val constructors = if (classOf[RuntimeReplaceable].isAssignableFrom(tag.runtimeClass)) {
-      val all = tag.runtimeClass.getConstructors
-      val maxNumArgs = all.map(_.getParameterCount).max
-      all.filterNot(_.getParameterCount == maxNumArgs)
-    } else {
-      tag.runtimeClass.getConstructors
-    }
-    // See if we can find a constructor that accepts Seq[Expression]
-    val varargCtor = constructors.find(_.getParameterTypes.toSeq == Seq(classOf[Seq[_]]))
-    val builder = (expressions: Seq[Expression]) => {
-      if (varargCtor.isDefined) {
-        // If there is an apply method that accepts Seq[Expression], use that one.
-        try {
-          varargCtor.get.newInstance(expressions).asInstanceOf[Expression]
-        } catch {
-          // the exception is an invocation exception. To get a meaningful message, we need the
-          // cause.
-          case e: Exception => throw new AnalysisException(e.getCause.getMessage)
-        }
-      } else {
-        // Otherwise, find a constructor method that matches the number of arguments, and use that.
-        val params = Seq.fill(expressions.size)(classOf[Expression])
-        val f = constructors.find(_.getParameterTypes.toSeq == params).getOrElse {
-          val validParametersCount = constructors
-            .filter(_.getParameterTypes.forall(_ == classOf[Expression]))
-            .map(_.getParameterCount).distinct.sorted
-          val invalidArgumentsMsg = if (validParametersCount.length == 0) {
-            s"Invalid arguments for function $name"
-          } else {
-            val expectedNumberOfParameters = if (validParametersCount.length == 1) {
-              validParametersCount.head.toString
-            } else {
-              validParametersCount.init.mkString("one of ", ", ", " and ") +
-                validParametersCount.last
-            }
-            s"Invalid number of arguments for function $name. " +
-              s"Expected: $expectedNumberOfParameters; Found: ${params.length}"
-          }
-          throw new AnalysisException(invalidArgumentsMsg)
-        }
-        try {
-          val exp = f.newInstance(expressions : _*).asInstanceOf[Expression]
-          exp.setTagValue(exp.FUNC_ALIAS, name)
-          exp
-        } catch {
-          // the exception is an invocation exception. To get a meaningful message, we need the
-          // cause.
-          case e: Exception => throw new AnalysisException(e.getCause.getMessage)
-        }
-      }
-    }
-
-    (name, (expressionInfo[T](name), builder))
+    expression[T](name, true)
   }
 
   /**