switch type length calculation to a less brittle solution

Author: Daniel Trinh

scalariform/src/main/scala/scalariform/formatter/CaseClauseFormatter.scala

@@ -70,12 +70,8 @@ trait CaseClauseFormatter { self: HasFormattingPreferences with ExprFormatter wi
         case (caseClause @ CaseClause(casePattern, statSeq)) :: otherClauses ⇒
           val otherClausesGrouped = groupClauses(otherClauses, first = false)
 
-          val formattedCasePattern = {
-            val casePatternSource = getSource(casePattern)
-            val casePatternFormatResult = formatCasePattern(casePattern)(FormatterState(indentLevel = 0))
-            val offset = casePattern.firstToken.offset
-            val edits = writeTokens(casePatternSource, casePattern.tokens, casePatternFormatResult, offset)
-            TextEditProcessor.runEdits(casePatternSource, edits)
+          val formattedCasePattern = formattedAstNode(casePattern) {
+            formatCasePattern(casePattern)(FormatterState(indentLevel = 0))
           }
 
           val newlineBeforeClause = hiddenPredecessors(caseClause.firstToken).containsNewline ||

scalariform/src/main/scala/scalariform/formatter/ExprFormatter.scala

@@ -927,21 +927,15 @@ trait ExprFormatter { self: HasFormattingPreferences with AnnotationFormatter wi
     }
   }
 
+  // TODO: Parts of this function might be useful in implementing other alignment features
   private def calculateParamSectionLengths(param: Param, first: Boolean)(implicit formatterState: FormatterState): Option[ParamSectionLengths] = {
     val Param(annotations, modifiers, valOrVarOpt, id, paramTypeOpt, defaultValueOpt) = param
 
-    val formattedParam = {
-      val source = getSource(param)
-      val paramFormatResult = format(param)(formatterState)
-      val offset = param.firstToken.offset
-      val edits = writeTokens(source, param.tokens, paramFormatResult, offset)
-      TextEditProcessor.runEdits(source, edits)
+    val formattedParam = formattedAstNode(param) {
+      format(param)(formatterState)
     }
 
-    // TODO: is there a less brittle way of calculating the extra '+ 1' character
-    // spaces besides guessing?
     def calculateLengths: ParamSectionLengths = {
-
       def calculatePrefixLength: Int = {
         // Calculate longest "prefix" length. Annotations, modifiers, and val/var contribute
         // to this number.
@@ -974,37 +968,16 @@ trait ExprFormatter { self: HasFormattingPreferences with AnnotationFormatter wi
       }
 
       def calculateTypeLength: Int = {
-        val spacesInsideBrackets = formattingPreferences(SpaceInsideBrackets)
         // Calculate longest "type" length.
-        var typeLength = 0
-        for ((_, typeAst) ← paramTypeOpt) {
-          val firstTypeToken :: otherTypeTokens = typeAst.tokens
-
-          // Add one to count, accounting for spaces in call by name params, (ex: => String)
-          if (firstTypeToken.tokenType == ARROW)
-            typeLength += 1
-
-          typeLength += firstTypeToken.length
-
-          otherTypeTokens.foreach { token ⇒
-
-            // Add two to count, accounting for spaces between brackets, (ex: Option[ String ])
-            if (spacesInsideBrackets && token.tokenType == RBRACKET)
-              typeLength += 2
-
-            // Add two to count, accounting for spaces in function types, (ex: Int => String)
-            if (token.tokenType == ARROW)
-              typeLength += 2
-
-            // Add one to count, accounting for spaces after commas, (ex: Map[Int, String])
-            if (token.tokenType == COMMA)
-              typeLength += 1
-
-            typeLength += token.length
-          }
+        val typeLengthOpt = paramTypeOpt map {
+          case (_, typeAst) ⇒
+            val formattedType = formattedAstNode(typeAst) {
+              format(typeAst)(formatterState)
+            }
+            formattedType.length
         }
 
-        typeLength
+        typeLengthOpt.getOrElse(0)
       }
 
       val prefixLength = calculatePrefixLength

scalariform/src/main/scala/scalariform/formatter/ScalaFormatter.scala

@@ -45,6 +45,23 @@ abstract class ScalaFormatter extends HasFormattingPreferences with TypeFormatte
     result
   }
 
+  /**
+   * Converts an AstNode into what it should look like in text after Scalariform has run.
+   * Useful for calculating the actual length of an [[scalariform.parser.AstNode]] after formatting.
+   *
+   * @param ast The AST to format and render as a string
+   * @param astFormatResult Should run formatting actions for 'ast'
+   * @return Formatted string representation of what the AstNode should look like after Scalariform
+   *         has run
+   */
+  protected def formattedAstNode(ast: AstNode)(astFormatResult: ⇒ FormatResult): String = {
+    val source = getSource(ast)
+    val formatResult = astFormatResult
+    val offset = ast.firstToken.offset
+    val edits = writeTokens(source, ast.tokens, formatResult, offset)
+    TextEditProcessor.runEdits(source, edits)
+  }
+
   private def alterSuspendFormatting(text: String): Option[Boolean] =
     if (text contains "format: OFF")
       Some(true)

scalariform/src/test/scala/scalariform/formatter/TemplateFormatterTest.scala

@@ -340,9 +340,22 @@ implicit val formattingPreferences = FormattingPreferences.setPreference(SpacesW
 {
    implicit val formattingPreferences = FormattingPreferences.
      setPreference(AlignParameters, true).
-     setPreference(PreserveDanglingCloseParenthesis, true)
-
-   """class a(
+     setPreference(PreserveDanglingCloseParenthesis, true).
+     setPreference(RewriteArrowSymbols, true)
+
+    // Formats rewritten arrows correctly
+    """def A(
+      |  a: A => B = null,
+      |  bee: => B = null,
+      |  c: B => C = null
+      |): D""" ==>
+    """def A(
+      |  a:   A ⇒ B = null,
+      |  bee: ⇒ B   = null,
+      |  c:   B ⇒ C = null
+      |): D"""
+
+  """class a(
      |  b: Int
      |)""" ==>
    """class a(