From 39d6cf646d86c7e27f5530c4fabbd0534a02ad57 Mon Sep 17 00:00:00 2001 From: Meriam Lachkar Date: Mon, 12 Oct 2020 16:35:15 +0200 Subject: [PATCH] Fix warn messages in doc (#1255) * Fix warn messages in doc * use -Wconf to silence warnings about non-exhaustive pattern matching in documentation * add Xfatal-warnings to docs project --- build.sbt | 2 + docs/developers/semantic-tree.md | 51 +++++++++---------- docs/developers/symbol-information.md | 12 ++--- docs/developers/symbol-matcher.md | 1 - docs/developers/tutorial.md | 2 +- .../src/main/scala/docs/website.scala | 6 ++- .../main/scala/scalafix/docs/PatchDocs.scala | 2 +- .../scalafix/test/ExplicitSynthetic.scala | 6 +-- 8 files changed, 42 insertions(+), 40 deletions(-) diff --git a/build.sbt b/build.sbt index 2c30c6dc8..7afdb184b 100644 --- a/build.sbt +++ b/build.sbt @@ -283,6 +283,8 @@ lazy val docs = project skip in publish := true, moduleName := "scalafix-docs", scalaVersion := scala213, + scalacOptions += "-Wconf:msg='match may not be exhaustive':s", // silence exhaustive pattern matching warning for documentation + scalacOptions += "-Xfatal-warnings", mdoc := run.in(Compile).evaluated, crossScalaVersions := List(scala213), libraryDependencies ++= List( diff --git a/docs/developers/semantic-tree.md b/docs/developers/semantic-tree.md index 4cc638533..6df2f5458 100644 --- a/docs/developers/semantic-tree.md +++ b/docs/developers/semantic-tree.md @@ -32,7 +32,6 @@ The variable `doc` in the code examples is an implicit instance of ```scala mdoc:passthrough import scalafix.docs.PatchDocs def println(a: Any): Unit = PatchDocs.println(a) -import scalafix.docs.PatchDocs._ implicit var doc: SemanticDocument = null ``` @@ -53,21 +52,21 @@ parameters doc.tree.traverse { // Option.apply case option @ Term.Select(Term.Name("Option"), Term.Name("apply")) => - println("synthetic = " + option.synthetic) - println("structure = " + option.synthetic.structure) + println("synthetic = " + option.synthetics) + println("structure = " + option.synthetics.structure) } ``` The asterisk `*` represents an `OriginalTree` node that matches the enclosing non-synthetic tree, which is `List` in this example. -The `.synthetic` method is only available on `Term` nodes, using the method on +The `.synthetics` method is only available on `Term` nodes, using the method on other tree nodes such as types results in compilation error ```scala mdoc:fail doc.tree.traverse { case app @ Type.Name("App") => - println(".synthetic = " + app.synthetic) + println(".synthetic = " + app.synthetics) } ``` @@ -83,21 +82,21 @@ Option[Int](2) // inferred: Option.apply[Int](2) """) ``` -Use `Tree.synthetic` in combination with `SemanticTree.symbol` to get the symbol +Use `Tree.synthetics` in combination with `SemanticTree.symbol` to get the symbol of those inferred `.apply` method calls. ```scala mdoc doc.tree.traverse { case Term.Apply(add @ q"add", List(q"2")) => println("add(2)") - println("synthetic = " + add.synthetic) - println("symbol = " + add.synthetic.flatMap(_.symbol).structure) - println("structure = " + add.synthetic.structure) + println("synthetic = " + add.synthetics) + println("symbol = " + add.synthetics.flatMap(_.symbol).structure) + println("structure = " + add.synthetics.structure) case Term.ApplyType(option @ q"Option", List(t"Int")) => println("Option[Int]") - println("synthetic = " + option.synthetic) - println("symbol = " + option.synthetic.flatMap(_.symbol).structure) - println("structure = " + option.synthetic.structure) + println("synthetic = " + option.synthetics) + println("symbol = " + option.synthetics.flatMap(_.symbol).structure) + println("structure = " + option.synthetics.structure) } ``` @@ -124,14 +123,14 @@ Main.run // implicit argument: message """) ``` -Use `Tree.synthetic` to look up an implicit argument for any `Term` node. +Use `Tree.synthetics` to look up an implicit argument for any `Term` node. ```scala mdoc doc.tree.traverse { - case term: Term if term.synthetic.isDefined => + case term: Term if term.synthetics.nonEmpty => println("term = " + term.syntax) - println("synthetic = " + term.synthetic) - println("structure = " + term.synthetic.structure) + println("synthetics = " + term.synthetics) + println("structure = " + term.synthetics.structure) } ``` @@ -146,18 +145,18 @@ List(1) ++ List(2) """) ``` -Use the `Term.ApplyInfix.syntheticOperator` to look up inferred type parameters +Use the `Term.ApplyInfix.syntheticOperators` to look up inferred type parameters of infix operators. ```scala mdoc doc.tree.traverse { case concat @ Term.ApplyInfix(_, Term.Name("++"), _, _) => - println(".syntheticOperator = " + concat.syntheticOperator) - println(".structure = " + concat.syntheticOperator.structure) + println(".syntheticOperators = " + concat.syntheticOperators) + println(".structure = " + concat.syntheticOperators.structure) } ``` -The `.syntheticOperator` method is only available for `Term.ApplyInfix` nodes, +The `.syntheticOperators` method is only available for `Term.ApplyInfix` nodes, using the method on other node types results in a compilation error [comment]: <> (Todo: add mdoc:fail for this snippet!) @@ -173,7 +172,7 @@ Beware that looking up synthetics for the infix operator name returns nothing ```scala mdoc doc.tree.traverse { case concat @ Term.Name("++") => - println(".synthetic = " + concat.synthetic) + println(".synthetics = " + concat.synthetics) } ``` @@ -191,18 +190,18 @@ for (number <- numbers) println(number) """) ``` -Use `Tree.synthetic` on the tree node `Term.ForYield` to inspect the desugared +Use `Tree.synthetics` on the tree node `Term.ForYield` to inspect the desugared version of the `for { .. } yield` expression ```scala mdoc doc.tree.traverse { case forYield: Term.ForYield => - println(".synthetic = " + forYield.synthetic) + println(".synthetics = " + forYield.synthetics) } ``` The `orig(List(1, 2))` and `orig(1.to(i)` parts represent `OriginalSubTree` -nodes that match non-synthetic tree nodes from the original for-comprension. +nodes that match non-synthetic tree nodes from the original for-comprehension. ## Known limitations @@ -228,7 +227,7 @@ Observe the empty `withFilter` body and `` parameter symbol. ```scala mdoc doc.tree.traverse { case forYield: Term.ForYield => - println(forYield.synthetic) + println(forYield.synthetics) } ``` @@ -250,7 +249,7 @@ Observe the `` parameter symbol to the final call to `map`. ```scala mdoc doc.tree.traverse { case forYield: Term.ForYield => - println(forYield.synthetic) + println(forYield.synthetics) } ``` diff --git a/docs/developers/symbol-information.md b/docs/developers/symbol-information.md index 898d141d5..159211ad1 100644 --- a/docs/developers/symbol-information.md +++ b/docs/developers/symbol-information.md @@ -238,9 +238,9 @@ Use `ClassSignature.parents` and `TypeRef.symbol` to lookup the class hierarchy. def getParentSymbols(symbol: Symbol): Set[Symbol] = symbol.info.get.signature match { case ClassSignature(_, parents, _, _) => - Set(symbol) ++ parents.flatMap { + Set(symbol) ++ parents.collect { case TypeRef(_, symbol, _) => getParentSymbols(symbol) - } + }.flatten } getParentSymbols(Symbol("java/lang/String#")) ``` @@ -256,9 +256,9 @@ def getClassMethods(symbol: Symbol): Set[SymbolInformation] = symbol.info.get.signature match { case ClassSignature(_, parents, _, declarations) => val methods = declarations.filter(_.isMethod) - methods.toSet ++ parents.flatMap { + methods.toSet ++ parents.collect { case TypeRef(_, symbol, _) => getClassMethods(symbol) - } + }.flatten case _ => Set.empty } getClassMethods(Symbol("scala/Some#")).take(5) @@ -368,9 +368,9 @@ def getMethodOverloads(classSymbol: Symbol, methodName: String): Set[SymbolInfor declaration.isMethod && declaration.displayName == methodName } - overloadedMethods.toSet ++ parents.flatMap { + overloadedMethods.toSet ++ parents.collect { case TypeRef(_, symbol, _) => getMethodOverloads(symbol, methodName) - } + }.flatten case _ => Set.empty } getMethodOverloads(Symbol("java/lang/String#"), "substring") diff --git a/docs/developers/symbol-matcher.md b/docs/developers/symbol-matcher.md index 4db0507c3..657ffd93c 100644 --- a/docs/developers/symbol-matcher.md +++ b/docs/developers/symbol-matcher.md @@ -30,7 +30,6 @@ import scala.meta._ ```scala mdoc:passthrough import scalafix.docs.PatchDocs def println(a: Any): Unit = PatchDocs.println(a) -import scalafix.docs.PatchDocs._ ``` ## SemanticDB diff --git a/docs/developers/tutorial.md b/docs/developers/tutorial.md index f211a1b9c..fc591bb85 100644 --- a/docs/developers/tutorial.md +++ b/docs/developers/tutorial.md @@ -162,7 +162,7 @@ trees. ```scala mdoc println(q"complete(true)".structure) // line wrap at 80th column -println(q"complete(true)".structure(30)) // line wrap at 30th column +println(q"complete(true)".structureWidth(30)) // line wrap at 30th column ``` The output of `tree.structure` can be copy-pasted for use in pattern matching. diff --git a/scalafix-docs/src/main/scala/docs/website.scala b/scalafix-docs/src/main/scala/docs/website.scala index 0af487124..cecc8ed98 100644 --- a/scalafix-docs/src/main/scala/docs/website.scala +++ b/scalafix-docs/src/main/scala/docs/website.scala @@ -84,14 +84,16 @@ package object website { default: T )(implicit settings: Settings[T], ev: T <:< Product): List[(Setting, Any)] = { settings.settings - .zip(default.productIterator.toIterable) + .zip(default.productIterator.iterator.to(Iterable)) .filterNot { case (setting, _) => setting.isHidden } .flatMap { case (s, d: SimpleDefinitions) => (s, d.kinds.mkString("['", "', '", "']")) :: Nil case (deepSetting, defaultSetting: Product) if deepSetting.underlying.nonEmpty => - deepSetting.flat.zip(defaultSetting.productIterator.toIterable) + deepSetting.flat.zip( + defaultSetting.productIterator.iterator.to(Iterable) + ) case (s, lst: Iterable[_]) => val rendered = lst.map(render) val string = diff --git a/scalafix-docs/src/main/scala/scalafix/docs/PatchDocs.scala b/scalafix-docs/src/main/scala/scalafix/docs/PatchDocs.scala index 99f9bd640..93affa7b6 100644 --- a/scalafix-docs/src/main/scala/scalafix/docs/PatchDocs.scala +++ b/scalafix-docs/src/main/scala/scalafix/docs/PatchDocs.scala @@ -28,7 +28,7 @@ object PatchDocs { doc .nested(ctx.indentCount * ctx.indentStep) .renderStream(ctx.leftOffset) - .toIterator + .iterator } x match { case t: SemanticTree => diff --git a/scalafix-tests/unit/src/main/scala/scalafix/test/ExplicitSynthetic.scala b/scalafix-tests/unit/src/main/scala/scalafix/test/ExplicitSynthetic.scala index bb9c623d4..89e773ae2 100644 --- a/scalafix-tests/unit/src/main/scala/scalafix/test/ExplicitSynthetic.scala +++ b/scalafix-tests/unit/src/main/scala/scalafix/test/ExplicitSynthetic.scala @@ -24,10 +24,10 @@ class ExplicitSynthetic(insertInfixTypeParam: Boolean) case Term.Select(_, Term.Name("apply")) => // happens for explicit "List.apply" because Synthetic.symbol returns Some(symbol) // for OriginalTree. - None + List() case infix: Term.ApplyInfix if insertInfixTypeParam => for { - synthetic <- infix.syntheticOperator.collect { + synthetic <- infix.syntheticOperators.collect { case tappl: TypeApplyTree => tappl } } yield { @@ -43,7 +43,7 @@ class ExplicitSynthetic(insertInfixTypeParam: Boolean) } case t: Term => for { - synthetic <- t.synthetic + synthetic <- t.synthetics sym <- synthetic.symbol if sym.displayName == "apply" } yield {