1 files changed, 35 insertions, 3 deletions
diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala
index cddb0c8f72..f72c1eb1b3 100644
--- a/src/reflect/scala/reflect/internal/StdAttachments.scala
+++ b/src/reflect/scala/reflect/internal/StdAttachments.scala
@@ -38,10 +38,31 @@ trait StdAttachments {
    */
   case class CompoundTypeTreeOriginalAttachment(parents: List[Tree], stats: List[Tree])
 
+  /** Attached to a Function node during type checking when the expected type is a SAM type (and not a built-in FunctionN).
+    *
+    * Ideally, we'd move to Dotty's Closure AST, which tracks the environment,
+    * the lifted method that has the implementation, and the target type.
+    * For backwards compatibility, an attachment is the best we can do right now.
+    *
+    * @param samTp the expected type that triggered sam conversion (may be a subtype of the type corresponding to sam's owner)
+    * @param sam the single abstract method implemented by the Function we're attaching this to
+    *
+    * @since 2.12.0-M4
+    */
+  case class SAMFunction(samTp: Type, sam: Symbol) extends PlainAttachment
+
+  case object DelambdafyTarget extends PlainAttachment
+
   /** When present, indicates that the host `Ident` has been created from a backquoted identifier.
    */
   case object BackquotedIdentifierAttachment extends PlainAttachment
 
+  /** Indicates that the host `Ident` has been created from a pattern2 binding, `case x @ p`.
+   *  In the absence of named parameters in patterns, allows nuanced warnings for unused variables.
+   *  Hence, `case X(x = _) =>` would not warn; for now, `case X(x @ _) =>` is documentary if x is unused.
+   */
+  case object AtBoundIdentifierAttachment extends PlainAttachment
+
   /** Identifies trees are either result or intermediate value of for loop desugaring.
    */
   case object ForAttachment extends PlainAttachment
@@ -53,12 +74,23 @@ trait StdAttachments {
   /** Untyped list of subpatterns attached to selector dummy. */
   case class SubpatternsAttachment(patterns: List[Tree])
 
+  abstract class InlineAnnotatedAttachment
+  case object NoInlineCallsiteAttachment extends InlineAnnotatedAttachment
+  case object InlineCallsiteAttachment extends InlineAnnotatedAttachment
+
+  /** Attached to a local class that has its outer field elided. A `null` constant may be passed
+    * in place of the outer parameter, can help callers to avoid capturing the outer instance.
+    */
+  case object OuterArgCanBeElided extends PlainAttachment
+
+  case object UseInvokeSpecial extends PlainAttachment
+
+  /** An attachment carrying information between uncurry and erasure */
+  case class TypeParamVarargsAttachment(val typeParamRef: Type)
+
   /** Attached to a class symbol to indicate that its children have been observed
     * via knownDirectSubclasses. Children added subsequently will trigger an
     * error to indicate that the earlier observation was incomplete.
     */
   case object KnownDirectSubclassesCalled extends PlainAttachment
-
-  /** An attachment carrying information between uncurry and erasure */
-  case class TypeParamVarargsAttachment(val typeParamRef: Type)
 }