Update extension method syntax

Author: bishabosha

community-build/community-projects/shapeless

@@ -13,6 +13,6 @@ trait AnnotationOps extends Core with
 
       def unapply(annot: Annotation)(given Context): Option[Symbol] = internal.Annotation_Child_unapply(annot)
 
-  given AnnotationOps: (annot: Annotation) with
+  given AnnotationOps: (annot: Annotation) extended with
     def tree(given Context): tpd.Tree = internal.Annotation_tree(annot)
     def symbol(given Context): Symbol = internal.Annotation_symbol(annot)

tasty/src/dotty/tools/tasty/experimental/bridge/AnnotationOps.scala

@@ -4,6 +4,6 @@ import reflect.ClassTag
 
 trait CommentOps extends Core with
 
-  given CommentOps: (comment: Comment) with
+  given CommentOps: (comment: Comment) extended with
     def raw: String = internal.Comment_raw(comment)
     def span: Span = internal.Comment_span(comment)

tasty/src/dotty/tools/tasty/experimental/bridge/CommentOps.scala

@@ -21,7 +21,7 @@ trait ConstantOps extends Core with
     final val EnumTag    = internal.Constants_EnumTag
   end Constants
 
-  given ConstantOps: (c: Constant) with
+  given ConstantOps: (c: Constant) extended with
     def tag: Int = internal.Constant_tag(c)
     def intValue: Int = internal.Constant_intValue(c)
     def booleanValue: Boolean = internal.Constant_booleanValue(c)

tasty/src/dotty/tools/tasty/experimental/bridge/ConstantOps.scala

@@ -5,12 +5,12 @@ import java.nio.file.Path
 
 trait ContextOps extends Core with
 
-  given ContextOps: (ctx: Context) with
+  given ContextOps: (ctx: Context) extended with
     def log(msg: => String, sourcePos: SourcePosition): Unit = internal.Context_log(ctx, msg, sourcePos)
     def source: SourceFile = internal.Context_source(ctx)
     def docCtx: Option[ContextDocstrings] = internal.Context_docCtx(ctx)
     def withOwner(owner: Symbol): Context = internal.Context_withOwner(ctx, owner)
     def withSource(source: SourceFile): Context = internal.Context_withSource(ctx, source)
 
-  given ContextDocstringsOps: (ctx: ContextDocstrings) with
+  given ContextDocstringsOps: (ctx: ContextDocstrings) extended with
     def docstring(sym: Symbol): Option[Comment] = internal.ContextDocstrings_docstring(ctx, sym)

tasty/src/dotty/tools/tasty/experimental/bridge/ContextOps.scala

@@ -43,7 +43,7 @@ trait FlagOps extends Core with
     val Open: Flag = internal.Flags_Open
   end Flags
 
-  given FlagSetOps: (flags: FlagSet)
+  given FlagSetOps: (flags: FlagSet) extended with
     def is(flag: Flag): Boolean = internal.FlagSet_is(flags, flag)
     def is(flag: Flag, butNot: FlagSet): Boolean = internal.FlagSet_is(flags, flag, butNot)
     def &~(flag: Flag): FlagSet = internal.FlagSet_&~(flags, flag)

tasty/src/dotty/tools/tasty/experimental/bridge/FlagOps.scala

@@ -35,14 +35,14 @@ trait NameOps extends Core with
     def unapply(name: DerivedName): Option[(TermName, Int)] = internal.OuterSelectName_unapply(name)
 
 
-  given NameOps: (name: Name) with
+  given NameOps: (name: Name) extended with
     def toTermName: TermName = internal.Name_toTermName(name)
     def isEmpty: Boolean = internal.Name_isEmpty(name)
     def isTypeName: Boolean = internal.Name_isTypeName(name)
     def isTermName: Boolean = !name.isTypeName
 
-  given TermNameOps: (name: TermName) with
+  given TermNameOps: (name: TermName) extended with
     def tag: Int = internal.TermName_tag(name)
 
-  given SimpleNameOps: (name: SimpleName) with
+  given SimpleNameOps: (name: SimpleName) extended with
     def toUTF8: Array[Byte] = internal.SimpleName_toUTF8(name)

tasty/src/dotty/tools/tasty/experimental/bridge/NameOps.scala

@@ -4,20 +4,20 @@ import reflect.ClassTag
 
 trait PositionOps extends Core with
 
-  given PositionedOps: (positioned: Positioned) with
+  given PositionedOps: (positioned: Positioned) extended with
 
     /** True if x's position shouldn't be reconstructed automatically from its initial span
      */
     def alwaysNeedsPos: Boolean = internal.Positioned_alwaysNeedsPos(positioned)
 
-  given SourcePositionOps: (pos: SourcePosition) with
+  given SourcePositionOps: (pos: SourcePosition) extended with
     def line: Int = internal.SourcePosition_line(pos)
 
   object Span with
     val empty: Span = internal.Span_empty
     val noSpan: Span = internal.Span_noSpan
 
-  given SpanOps: (span: Span) with
+  given SpanOps: (span: Span) extended with
     def coords: Long = internal.Span_coords(span)
     def isSynthetic: Boolean = internal.Span_isSynthetic(span)
     def toSynthetic: Span = internal.Span_toSynthetic(span)

tasty/src/dotty/tools/tasty/experimental/bridge/PositionOps.scala

@@ -14,11 +14,11 @@ trait SignatureOps extends Core with
 
     def unapply(signature: Signature): (List[ParamSig], TypeName) = internal.Signature_unapply(signature)
 
-    given ParamSigOps: (paramSig: ParamSig) with
+    given ParamSigOps: (paramSig: ParamSig) extended with
       def fold[A](onInt: Int => A, onTypeName: TypeName => A): A = internal.Signature_ParamSig_fold(paramSig)(onInt, onTypeName)
       def foldInt(onInt: IntToInt, onTypeName: ToInt[TypeName]): Int = internal.Signature_ParamSig_foldInt(paramSig)(onInt, onTypeName)
 
   end Signature
 
-  given SignatureOps: (signature: Signature) with
+  given SignatureOps: (signature: Signature) extended with
     def isNotAMethod: Boolean = internal.Signature_isNotAMethod(signature)

tasty/src/dotty/tools/tasty/experimental/bridge/SignatureOps.scala

@@ -7,6 +7,6 @@ trait SourceFileOps extends Core with
   object SourceFile with
     val noSource: SourceFile = internal.SourceFile_noSource
 
-  given SourceFileOps: (source: SourceFile) with
+  given SourceFileOps: (source: SourceFile) extended with
     def path: String = internal.SourceFile_path(source)
     def exists: Boolean = internal.SourceFile_exists(source)

tasty/src/dotty/tools/tasty/experimental/bridge/SourceFileOps.scala

@@ -4,8 +4,8 @@ import reflect.ClassTag
 
 trait StringOps extends Core with
 
-  given StringOps: (string: String) with
+  given StringOps: (string: String) extended with
     def toTermName: TermName = internal.String_toTermName(string)
 
-  given StringContextOps: (stringContext: StringContext) with
+  given StringContextOps: (stringContext: StringContext) extended with
     def i(args: => Any*)(given Context): String = internal.StringContext_i(stringContext, args)

tasty/src/dotty/tools/tasty/experimental/bridge/StringOps.scala

@@ -17,9 +17,8 @@ trait SymbolOps extends Core with
 
     def newMutableSymbolMap[T]: MutableSymbolMap[T] = internal.Symbols_newMutableSymbolMap[T]
 
-    given MutableSymbolMapOps: [T](map: Symbols.MutableSymbolMap[T]) with
+    given MutableSymbolMapOps: [T](map: Symbols.MutableSymbolMap[T]) extended with
       def get(sym: Symbol): Option[T] = internal.Symbols_MutableSymbolMap_get(map, sym)
-      def getOrElse[U >: T](sym: Symbol, default: => U): U = internal.Symbols_MutableSymbolMap_getOrElse(map, sym, default)
       def contains(sym: Symbol): Boolean = internal.Symbols_MutableSymbolMap_contains(map, sym)
       def update(sym: Symbol, value: T): Unit = internal.Symbols_MutableSymbolMap_update(map, sym, value)
       def -=(sym: Symbol): Unit = internal.Symbols_MutableSymbolMap_-=(map, sym)
@@ -28,9 +27,14 @@ trait SymbolOps extends Core with
       def keysIterator: Iterator[Symbol] = internal.Symbols_MutableSymbolMap_keysIterator(map)
     end MutableSymbolMapOps
 
+    given MutableSymbolMapOpsPlus: AnyRef with
+      def [T, U >: T](map: Symbols.MutableSymbolMap[T]) getOrElse(sym: Symbol, default: => U): U =
+        internal.Symbols_MutableSymbolMap_getOrElse(map, sym, default)
+    end MutableSymbolMapOpsPlus
+
   end Symbols
 
-  given SymbolOps: (sym: Symbol) with
+  given SymbolOps: (sym: Symbol) extended with
     def isPackage(given Context): Boolean = internal.Symbol_isPackage(sym)
     def isPrivate(given Context): Boolean = internal.Symbol_isPrivate(sym)
     def sourcePos(given Context): SourcePosition = internal.Symbol_sourcePos(sym)

tasty/src/dotty/tools/tasty/experimental/bridge/SymbolOps.scala

@@ -195,44 +195,44 @@ trait TreeOps extends Core with
     object Ident with
       def unapply(tree: Ident): Some[Name] = internal.untpd_Ident_unapply(tree)
 
-    given ImportSelectorOps: (tree: ImportSelector) with
+    given ImportSelectorOps: (tree: ImportSelector) extended with
       def imported: Ident = internal.ImportSelector_imported(tree)
       def renamed: Tree = internal.ImportSelector_renamed(tree)
       def bound: Tree = internal.ImportSelector_bound(tree)
 
   end untpd
 
-  given untpdTreeOps: (tree: untpd.Tree) with
+  given untpdTreeOps: (tree: untpd.Tree) extended with
     def symbol(given Context): Symbol = internal.untpd_Tree_symbol(tree)
     def span: Span = internal.untpd_Tree_span(tree)
     def source: SourceFile = internal.untpd_Tree_source(tree)
     def envelope(src: SourceFile, startSpan: Span = Span.noSpan): Span = internal.untpd_Tree_envelope(tree, src, startSpan)
     def withType(tpe: Type)(given Context): tpd.Tree = internal.untpd_Tree_withType(tree, tpe)
     def isEmpty: Boolean = internal.untpd_Tree_isEmpty(tree)
 
-  given TreeOps: (tree: tpd.Tree) with
+  given TreeOps: (tree: tpd.Tree) extended with
     def isType: Boolean = internal.Tree_isType(tree)
     def tpe: Type = internal.Tree_tpe(tree)
 
-  given IfOps: (tree: tpd.If) with
+  given IfOps: (tree: tpd.If) extended with
     def isInline: Boolean = internal.If_isInline(tree)
 
-  given MatchOps: (tree: tpd.Match) with
+  given MatchOps: (tree: tpd.Match) extended with
     def isInline: Boolean = internal.Match_isInline(tree)
 
-  given ValOrDefDefOps: (tree: tpd.ValOrDefDef) with
+  given ValOrDefDefOps: (tree: tpd.ValOrDefDef) extended with
     def name: TermName = internal.ValOrDefDef_name(tree)
     def tpt: tpd.Tree = internal.ValOrDefDef_tpt(tree)
     def rhs(given Context): tpd.Tree = internal.ValOrDefDef_rhs(tree)
 
-  given DefDefOps: (tree: tpd.DefDef) with
+  given DefDefOps: (tree: tpd.DefDef) extended with
     def tparams: List[tpd.TypeDef] = internal.DefDef_tparams(tree)
     def vparamss: List[List[tpd.ValDef]] = internal.DefDef_vparamss(tree)
 
-  given TypeDefOps: (tree: tpd.TypeDef) with
+  given TypeDefOps: (tree: tpd.TypeDef) extended with
     def rhs: tpd.Tree = internal.TypeDef_rhs(tree)
 
-  given TemplateOps: (tree: tpd.Template) with
+  given TemplateOps: (tree: tpd.Template) extended with
     def decomposeBody(given Context): (List[tpd.Tree], List[tpd.Tree]) = internal.Template_decomposeBody(tree)
     def parents: List[tpd.Tree] = internal.Template_parents(tree)
     def self: tpd.ValDef = internal.Template_self(tree)

tasty/src/dotty/tools/tasty/experimental/bridge/TreeOps.scala

@@ -33,7 +33,7 @@ trait TypeOps extends Core with
   object AppliedType with
     def unapply(tpe: AppliedType): (Type, List[Type]) = internal.AppliedType_unapply(tpe)
 
-  given TypeOps: (tpe: Type) with
+  given TypeOps: (tpe: Type) extended with
     def stripTypeVar(given Context): Type = internal.Type_stripTypeVar(tpe)
     def signature(given Context): Signature = internal.Type_signature(tpe)
     def member(name: Name)(given Context): Symbol = internal.Type_member(tpe, name)
@@ -42,71 +42,71 @@ trait TypeOps extends Core with
     def isErasedMethod: Boolean = internal.Type_isErasedMethod(tpe)
     def exists: Boolean = internal.Type_exists(tpe)
 
-  given ConstantTypeOps: (tpe: ConstantType) with
+  given ConstantTypeOps: (tpe: ConstantType) extended with
     def value: Constant = internal.ConstantType_value(tpe)
 
-  given SuperTypeOps: (tpe: SuperType) with
+  given SuperTypeOps: (tpe: SuperType) extended with
     def thistpe: Type = internal.SuperType_thistpe(tpe)
     def supertpe: Type = internal.SuperType_supertpe(tpe)
 
-  given ThisTypeOps: (tpe: ThisType) with
+  given ThisTypeOps: (tpe: ThisType) extended with
     def cls(given Context): ClassSymbol = internal.ThisType_cls(tpe)
     def tref: TypeRef = internal.ThisType_tref(tpe)
 
-  given SkolemTypeOps: (tpe: SkolemType) with
+  given SkolemTypeOps: (tpe: SkolemType) extended with
     def info: Type = internal.SkolemType_info(tpe)
 
-  given BoundTypeOps: (tpe: BoundType) with
+  given BoundTypeOps: (tpe: BoundType) extended with
     def binder: tpe.BT = internal.BoundType_binder(tpe)
 
-  given ParamRefOps: (tpe: ParamRef) with
+  given ParamRefOps: (tpe: ParamRef) extended with
     def paramNum: Int = internal.ParamRef_paramNum(tpe)
 
-  given RecTypeOps: (tpe: RecType) with
+  given RecTypeOps: (tpe: RecType) extended with
     def parent: Type = internal.RecType_parent(tpe)
 
-  given RefinedTypeOps: (tpe: RefinedType) with
+  given RefinedTypeOps: (tpe: RefinedType) extended with
     def parent: Type = internal.RefinedType_parent(tpe)
     def refinedInfo: Type = internal.RefinedType_refinedInfo(tpe)
     def refinedName: Name = internal.RefinedType_refinedName(tpe)
 
-  given TypeBoundsOps: (tpe: TypeBounds) with
+  given TypeBoundsOps: (tpe: TypeBounds) extended with
     def hi: Type = internal.TypeBounds_hi(tpe)
     def lo: Type = internal.TypeBounds_lo(tpe)
 
-  given TypeAliasOps: (tpe: TypeAlias) with
+  given TypeAliasOps: (tpe: TypeAlias) extended with
     def alias: Type = internal.TypeAlias_alias(tpe)
 
-  given NamedTypeOps: (tpe: NamedType) with
+  given NamedTypeOps: (tpe: NamedType) extended with
     def symbol(given Context): Symbol = internal.NamedType_symbol(tpe)
     def prefix: Type = internal.NamedType_prefix(tpe)
     def designator: Designator = internal.NamedType_designator(tpe)
     def hasNoPrefix: Boolean = internal.NamedType_hasNoPrefix(tpe)
     def isType: Boolean = internal.NamedType_isType(tpe)
 
-  given AnnotatedTypeOps: (tpe: AnnotatedType) with
+  given AnnotatedTypeOps: (tpe: AnnotatedType) extended with
     def parent: Type = internal.AnnotatedType_parent(tpe)
     def annot: Annotation = internal.AnnotatedType_annot(tpe)
 
-  given AndOrTypeOps: (tpe: AndOrType) with
+  given AndOrTypeOps: (tpe: AndOrType) extended with
     def tp1: Type = internal.AndOrType_tp1(tpe)
     def tp2: Type = internal.AndOrType_tp2(tpe)
 
-  given TypeProxyOps: (tpe: TypeProxy) with
+  given TypeProxyOps: (tpe: TypeProxy) extended with
     def underlying(given Context): Type = internal.TypeProxy_underlying(tpe)
 
-  given MatchTypeOps: (tpe: MatchType) with
+  given MatchTypeOps: (tpe: MatchType) extended with
     def bound: Type = internal.MatchType_bound(tpe)
     def scrutinee: Type = internal.MatchType_scrutinee(tpe)
     def cases: List[Type] = internal.MatchType_cases(tpe)
 
-  given LambdaTypeOps: (tpe: LambdaType) with
+  given LambdaTypeOps: (tpe: LambdaType) extended with
     def resultType(given Context): Type = internal.LambdaType_resultType(tpe)
     def paramNames: List[tpe.ThisName] = internal.LambdaType_paramNames(tpe)
     def paramInfos: List[tpe.PInfo] = internal.LambdaType_paramInfos(tpe)
 
-  given LazyRefOps: (tpe: LazyRef) with
+  given LazyRefOps: (tpe: LazyRef) extended with
     def ref(given Context): Type = internal.LazyRef_ref(tpe)
 
-  given ClassInfoOps: (tpe: ClassInfo) with
+  given ClassInfoOps: (tpe: ClassInfo) extended with
     def selfInfo: Either[Type, Symbol] = internal.ClassInfo_selfInfo(tpe)