Update docs

Author: nicolasstucki

docs/docs/reference/metaprogramming/inline.md

@@ -284,6 +284,21 @@ transparent inline def zero: Int = 0
 val one: 1 = zero + 1
 ```
 
+### Transparent vs. non-transparent inline
+As we already discussed, transparent inline methods will provide a more precise.
+Technically this implies that transparent inline methods must be expanded while typing the program. Other inline methods are inlined later after the program is fully typed.
+
+For example the following two functions will be typed the same way but will be inlined at different times.
+```scala
+inline def f1: T = ...
+transparent inline def f2: T = (...): T
+```
+
+A noteworthy difference is the behavior of `transparent inline given`.
+If there is an error reported when inlining that definition, it will be considered as an implicit search mismatch and the search will continue.
+A `transparent inline given` can add a type ascription in its RHS (as in `f2` from the previous example) to avoid the precise type but keep the search behavior.
+On the other hand `inline given` be taken as the implicit and then after typing is done the code is inlined and any error will be emitted as usual.
+
 ## Inline Conditionals
 
 An if-then-else expression whose condition is a constant expression can be simplified to
@@ -313,6 +328,8 @@ below:
    | This location is in code that was inlined at ...
 ```
 
+In a transparent inline, an `inline if` will force the inlining of any inline definition in its condition.
+
 ## Inline Matches
 
 A `match` expression in the body of an `inline` method definition may be

docs/docs/reference/metaprogramming/macros.md

@@ -618,9 +618,9 @@ def setForExpr[T: Type](using Quotes): Expr[Set[T]] =
       case _ => '{ new HashSet[T] }
 ```
 
-## Relationship with Whitebox Inline
+## Relationship with Transparent Inline
 
-[Inline](./inline.md) documents inlining. The code below introduces a whitebox
+[Inline](./inline.md) documents inlining. The code below introduces a transparent
 inline method that can calculate either a value of type `Int` or a value of type
 `String`.
 

library/src/scala/compiletime/testing/package.scala

@@ -2,6 +2,8 @@ package scala.compiletime
 package testing
 
 /** Whether the code type checks in the current context?
+ *
+ *  An inline definition with a call to `typeChecks` should be transparent.
  *
  *  @param code The code to be type checked
  *
@@ -20,6 +22,8 @@ transparent inline def typeChecks(inline code: String): Boolean =
  *  version to version. This API is to be used for testing purposes
  *  only.
  *
+ *  An inline definition with a call to `typeCheckErrors` should be transparent.
+ *
  *  @param code The code to be type checked
  *
  *  @return a list of errors encountered during parsing and typechecking.