Prepare the 3.1.3 release blogpost

blog/_posts/2022-06-15-scala-3.1.3-released.md

@@ -0,0 +1,108 @@
+---
+layout: blog-detail
+post-type: blog
+by: Paweł Marks, VirtusLab
+title: Scala 3.1.3 released!
+---
+
+We are happy to announce the release of Scala 3.1.3! You can read more about all the improvements and fixes in [the full changelog](https://github.com/lampepfl/dotty/releases/tag/3.1.3). We have also prepared a short highlights of the most exciting additions in the new version.
+
+## Highlights of the release
+
+### Improved f-interpolator
+
+f-interpolator in Scala 3 has received multiple fixes and improvements recently. Now it has reached feature parity with its Scala 2 counterpart.
+
+- Cases that were incorrectly failing are now working as intended:
+
+  ```scala
+  f"${3.14}%.2f rounds to ${3}%d"           // "3.14 rounds to 3"
+  f"${java.lang.Boolean.valueOf(false)}%b"  // "false"
+  f"${BigInt(120)}%d"                       // "120"
+  f"${3L}%e"                                // "3.000000e+00"
+  ```
+
+- Backslash escapes are now handled properly and consistently:
+
+  ```scala
+  f"yes\\\no"   // "yes\
+                //  o"
+  ```
+
+- Many cases that were throwing runtime exceptions are now causing compilation errors instead:
+
+  ```scala
+  f"{1} % y"  // Error: illegal conversion character 'y'
+  ```
+
+### Better error reporting in inlined code
+
+When the compiler reports an error that occurred in inlined code, it now displays the source from where the inlined function was invoked. That gives more context to the users on what happened and where the error came from.
+
+For example, the snippet:
+
+```scala
+trait Foo[X]:
+  def foo: Int
+
+def foo =
+  first[String]
+
+inline def second[A]: Int =
+  compiletime.summonInline[Foo[A]].foo
+
+inline def first[A]: Int =
+  second[A] + 42
+```
+
+will now report compilation error looking like this
+
+![the new error]({{ site.baseurl }}/resources/img/inline-error-after.png)
+
+instead of previous
+
+![the old error]({{ site.baseurl }}/resources/img/inline-error-before.png)
+
+### Possibility to generate arbitrary class implementations in macros
+
+For a long time, generating arbitrary classes was not possible using the quotes api. With 3.1.3, the situation has changed. We added two missing blocks: experimental methods `ClassDef.apply` and `Symbol.newClass`. Now using them, you can write a snippet similar to the following:
+
+```scala
+import scala.quoted.*
+
+class Base
+
+transparent inline def classNamed(inline name: String) = ${ classNamedExpr('name) }
+def classNamedExpr(nameExpr: Expr[String])(using Quotes): Expr[Any] =
+  import quotes.reflect.*
+
+  val name = nameExpr.valueOrAbort
+  val parents = List(TypeTree.of[Base])
+  def decls(cls: Symbol) = List.empty  // put something interesting here
+  val body = List.empty                // ...and here
+
+  val symbol = Symbol.newClass(Symbol.spliceOwner, name, parents.map(_.tpe), decls, selfType = None)
+  val classDef = ClassDef(symbol, parents, body)
+  val ctor = Select(New(TypeIdent(symbol)), symbol.primaryConstructor)
+  val newClass = Typed(Apply(ctor, Nil), TypeTree.of[Base])
+
+  Block(List(classDef), newClass).asExprOf[Base]
+```
+
+Then you can invoke the macro with
+
+```scala
+val impl: Base = classNamed("Foo")
+```
+
+creating the new instance of your custom subclass of `Base`. That can be useful for the compile-time generation of proxies for remote procedure call systems and many other advanced use-cases.
+
+## Contributors
+
+Thank you to all the contributors who made this release possible.
+
+According to `git shortlog -sn --no-merges 3.1.2..3.1.3` these are:
+
+```
+  // TODO
+```