Merge branch 'change-overload-lambda' of https://github.com/dotty-staging/dotty into change-overload-lambda

# Conflicts:
#	docs/docs/reference/changed-features/overload-resolution.md
#	tests/run/overloads.check
#	tests/run/overloads.scala

Author: odersky

docs/docs/reference/effects.md

@@ -0,0 +1,33 @@
+---
+layout: doc-page
+title: "Effects"
+---
+
+```scala
+package scala {
+  type Pure
+  type Impure <: Pure
+  type CanThrow[-Exc <: Throwable] >: Impure
+
+  def Try[T, Exc](body: implicit CanThrow[Exc] => T)(catcher: Exc => T): T = {
+    try {
+      implicit val canThrow: CanThrow[Exc] = Effect.isImpure
+      body
+    }
+    catch {
+      case exc: Exc => catcher(exc)
+    }
+  }
+}
+```
+
+```scala
+package scala
+object Effect {
+  val isImpure: Impure
+  val canThrowNPE: CanThrow[NullPointerException]
+  val canThrow: CanThrow[Throwable]
+}
+```
+
+import Effect.{_ => _}

docs/docs/reference/export.md

@@ -0,0 +1,48 @@
+---
+layout: doc-page
+title: "Export"
+---
+
+### Syntax changes:
+
+```
+TemplateStat      ::=  ...
+                    |  Export
+Export            ::=  ‘export’ ImportExprs
+```
+
+Similarly to imports, an export with several parts
+
+```
+export iexpr_1, ..., iexpr_n`
+```
+
+is a shorthand for
+
+```
+export iexpr_1
+...
+export iexpr_n`
+```
+
+To explain how export clauses influence type checking we explain in the following one possible scheme. As always, compilers are free to pick a different scheme if the observable results are the same.
+
+An export `export prefix . selectors` in a template is legal if `prefix` is a path that refers either to a member of the template or to a globally accessible object.
+Such an export generates a public "export" member with a compiler-generated name that's inaccessible to user programs and globally unique, and a special type
+
+    ExportType(PT, E)
+
+where `E` is the export clause itself and `PT` is the type of `prefix`. The `PT` part of an `ExportType` behaves as usual with regards to type maps such as substitution or as-seen-from.
+
+When typing a selection `p.m`, if `p` does not have a member named `m`, the following adaptation is tried before searching for an implicit conversion of `p`:
+
+Let `es` be all the export members of `p`. We first search all explicit exports and then, if that returns no results, all wildcard exports for a match with `m`, exactly as it is done when processing import statements. If there are several matching members they all must have the same prefix type `PT`, or an ambiguity error is reported. Otherwise, pick an arbitary element of the set of matching members, say member `e` defined in class `C` with type `ExportType(PT, export q . ss)`. The selection `p.m` is then rewritten to one of the following alternatives, depending on the form of `q`.
+
+  - If `q` refers to a globally accessible object: `q.m`
+  - If `q` is of the form `C.this . q_1 . ... q _n`: `p . q_1 . ... . q_n . m`
+
+
+
+
+
+

docs/docs/reference/other-new-features/exports.md

@@ -0,0 +1,48 @@
+---
+layout: doc-page
+title: "Export"
+---
+
+### Syntax changes:
+
+```
+TemplateStat      ::=  ...
+                    |  Export
+Export            ::=  ‘export’ ImportExprs
+```
+
+Similarly to imports, an export with several parts
+
+```
+export iexpr_1, ..., iexpr_n`
+```
+
+is a shorthand for
+
+```
+export iexpr_1
+...
+export iexpr_n`
+```
+
+To explain how export clauses influence type checking we explain in the following one possible scheme. As always, compilers are free to pick a different scheme if the observable results are the same.
+
+An export `export prefix . selectors` in a template is legal if `prefix` is a path that refers either to a member of the template or to a globally accessible object.
+Such an export generates a public "export" member with a compiler-generated name that's inaccessible to user programs and globally unique, and a special type
+
+    ExportType(PT, E)
+
+where `E` is the export clause itself and `PT` is the type of `prefix`. The `PT` part of an `ExportType` behaves as usual with regards to type maps such as substitution or as-seen-from.
+
+When typing a selection `p.m`, if `p` does not have a member named `m`, the following adaptation is tried before searching for an implicit conversion of `p`:
+
+Let `es` be all the export members of `p`. We first search all explicit exports and then, if that returns no results, all wildcard exports for a match with `m`, exactly as it is done when processing import statements. If there are several matching members they all must have the same prefix type `PT`, or an ambiguity error is reported. Otherwise, pick an arbitary element of the set of matching members, say member `e` defined in class `C` with type `ExportType(PT, export q . ss)`. The selection `p.m` is then rewritten to one of the following alternatives, depending on the form of `q`.
+
+  - If `q` refers to a globally accessible object: `q.m`
+  - If `q` is of the form `C.this . q_1 . ... q _n`: `p . q_1 . ... . q_n . m`
+
+
+
+
+
+

tests/pending/neg/matchtype-reduce.scala

@@ -0,0 +1,9 @@
+object Test {
+  type StringToInt[T] = T match {
+    case String => Int
+    case Any => T       // case t => t would be nice see (2) above
+  }
+
+  implicitly[StringToInt[String] =:= String]
+  implicitly[StringToInt[String] =:= Int]
+}

tests/pending/pos/i5535.scala

@@ -0,0 +1,21 @@
+object Test {
+  // The identity on types of the form N | P[a, P[b, ... P[z, N]]]
+  type Nested[X, P[_, _], N] = X match {
+    case N => N
+    case P[a, b] => P[a, Nested[b, P, N]]
+  }
+
+  // Type bound:
+  //   Recursion limit exceeded.
+  //   Maybe there is an illegal cyclic reference?
+  def p1[T <: Nested[T, Tuple2, Unit]](t: T): T = t
+  p1(())
+  p1((23, ()))
+  p1(("foo", (23, ())))
+
+  // Type constraint: OK
+  def p2[T](t: T)(erased implicit ev: T <:< Nested[T, Tuple2, Unit]): T = t
+  p2(())
+  p2((23, ()))
+  p2(("foo", (23, ())))
+}