[SPARK-22333][SQL]timeFunctionCall(CURRENT_DATE, CURRENT_TIMESTAMP) has conflicts with columnReference

sql/catalyst/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBase.g4

@@ -564,8 +564,7 @@ valueExpression
     ;
 
 primaryExpression
-    : name=(CURRENT_DATE | CURRENT_TIMESTAMP)                                                  #timeFunctionCall
-    | CASE whenClause+ (ELSE elseExpression=expression)? END                                   #searchedCase
+    : CASE whenClause+ (ELSE elseExpression=expression)? END                                   #searchedCase
     | CASE value=expression whenClause+ (ELSE elseExpression=expression)? END                  #simpleCase
     | CAST '(' expression AS dataType ')'                                                      #cast
     | STRUCT '(' (argument+=namedExpression (',' argument+=namedExpression)*)? ')'             #struct
@@ -747,7 +746,7 @@ nonReserved
     | NULL | ORDER | OUTER | TABLE | TRUE | WITH | RLIKE
     | AND | CASE | CAST | DISTINCT | DIV | ELSE | END | FUNCTION | INTERVAL | MACRO | OR | STRATIFY | THEN
     | UNBOUNDED | WHEN
-    | DATABASE | SELECT | FROM | WHERE | HAVING | TO | TABLE | WITH | NOT | CURRENT_DATE | CURRENT_TIMESTAMP
+    | DATABASE | SELECT | FROM | WHERE | HAVING | TO | TABLE | WITH | NOT
     | DIRECTORY
     | BOTH | LEADING | TRAILING
     ;
@@ -983,8 +982,6 @@ OPTION: 'OPTION';
 ANTI: 'ANTI';
 LOCAL: 'LOCAL';
 INPATH: 'INPATH';
-CURRENT_DATE: 'CURRENT_DATE';
-CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP';
 
 STRING
     : '\'' ( ~('\''|'\\') | ('\\' .) )* '\''

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

@@ -139,6 +139,7 @@ class Analyzer(
       ExtractGenerator ::
       ResolveGenerate ::
       ResolveFunctions ::
+      ResolveLiteralFunctions ::
       ResolveAliases ::
       ResolveSubquery ::
       ResolveSubqueryColumnAliases ::
@@ -1205,6 +1206,39 @@ class Analyzer(
     }
   }
 
+  /**
+   * Literal functions do not require the user to specify braces when calling them
+   * When an UnresolvedAttribute cannot be resolved as a column reference, we try to
+   * resolve it as a Literal function.
+   */
+  object ResolveLiteralFunctions extends Rule[LogicalPlan] {
+    // support CURRENT_DATE and CURRENT_TIMESTAMP
+    val literalFunctions = Seq(CurrentDate(), CurrentTimestamp())
+
+    def resolveAsFunctions(name: String): Option[NamedExpression] = {
+      val func = literalFunctions.find(e => resolver(e.prettyName, name))
+      if (func.isDefined) {
+        Some(Alias(func.get, toPrettySQL(func.get))())
+      } else {
+        None
+      }
+    }
+
+    def apply(plan: LogicalPlan): LogicalPlan = plan resolveOperators {
+      case p: LogicalPlan if p.childrenResolved =>
+        p transformExpressionsUp {
+          case u if !u.childrenResolved => u
+          case u @ UnresolvedAttribute(nameParts) if (nameParts.length == 1) =>
+            val result =
+              withPosition(u) {
+                resolveAsFunctions(nameParts.head).getOrElse(u)
+              }
+            logDebug(s"Resolving $u as Literal function $result")
+            result
+        }
+    }
+  }
+
   /**
    * This rule resolves and rewrites subqueries inside expressions.
    *

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala

@@ -1234,19 +1234,6 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging
     }
   }
 
-  /**
-   * Create a current timestamp/date expression. These are different from regular function because
-   * they do not require the user to specify braces when calling them.
-   */
-  override def visitTimeFunctionCall(ctx: TimeFunctionCallContext): Expression = withOrigin(ctx) {
-    ctx.name.getType match {
-      case SqlBaseParser.CURRENT_DATE =>
-        CurrentDate()
-      case SqlBaseParser.CURRENT_TIMESTAMP =>
-        CurrentTimestamp()
-    }
-  }
-
   /**
    * Create a function database (optional) and name pair.
    */

sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala

@@ -56,6 +56,24 @@ class DateFunctionsSuite extends QueryTest with SharedSQLContext {
     checkAnswer(sql("""SELECT CURRENT_TIMESTAMP() = NOW()"""), Row(true))
   }
 
+  test("SPARK-22333: timeFunctionCall has conflicts with columnReference ") {
+    val df = Seq((1, 2), (2, 3)).toDF("current_date", "current_timestamp")
+    df.createOrReplaceTempView("ttf")
+    withTempView("ttf") {
+      checkAnswer(sql("SELECT current_date, current_timestamp FROM ttf"),
+        Seq(Row(1, 2), Row(2, 3)))
+    }
+
+    val df1 = Seq((1, 2), (2, 3)).toDF("a", "b")
+    df1.createOrReplaceTempView("ttf1")
+    withTempView("ttf1") {
+      checkAnswer(
+        sql("SELECT current_date = current_date(), current_timestamp = current_timestamp(), " +
+          "a, b FROM ttf"),
+        Seq(Row(true, true, 1, 2), Row(true, true, 2, 3)))
+    }
+  }
+
   val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US)
   val sdfDate = new SimpleDateFormat("yyyy-MM-dd", Locale.US)
   val d = new Date(sdf.parse("2015-04-08 13:10:15").getTime)