Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit e5c0f50

Browse files
nicolasstuckinicolasstucki
committedNov 23, 2018
Add instace checks for TASTy relfect Tree.Terms
1 parent e8bd86f commit e5c0f50

File tree

2 files changed

+238
-81
lines changed

2 files changed

+238
-81
lines changed
 

‎compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala

Lines changed: 160 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
1313
def symbol(implicit ctx: Context): Symbol = tree.symbol
1414
}
1515

16-
object IsPackageClause extends IsPackageClauseExtractor {
16+
object IsPackageClause extends IsPackageClauseModule {
1717
def unapply(tree: Tree)(implicit ctx: Context): Option[PackageClause] = tree match {
1818
case x: tpd.PackageDef => Some(x)
1919
case _ => None
@@ -47,7 +47,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
4747

4848
// ----- Definitions ----------------------------------------------
4949

50-
object IsDefinition extends IsDefinitionExtractor {
50+
object IsDefinition extends IsDefinitionModule {
5151
def unapply(tree: Tree)(implicit ctx: Context): Option[Definition] = tree match {
5252
case tree: tpd.MemberDef => Some(tree)
5353
case tree: PackageDefinition => Some(tree)
@@ -61,7 +61,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
6161

6262
// ClassDef
6363

64-
object IsClassDef extends IsClassDefExtractor {
64+
object IsClassDef extends IsClassDefModule {
6565
def unapply(tree: Tree)(implicit ctx: Context): Option[ClassDef] = tree match {
6666
case x: tpd.TypeDef if x.isClassDef => Some(x)
6767
case _ => None
@@ -87,7 +87,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
8787

8888
// DefDef
8989

90-
object IsDefDef extends IsDefDefExtractor {
90+
object IsDefDef extends IsDefDefModule {
9191
def unapply(tree: Tree)(implicit ctx: Context): Option[DefDef] = tree match {
9292
case x: tpd.DefDef => Some(x)
9393
case _ => None
@@ -112,7 +112,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
112112

113113
// ValDef
114114

115-
object IsValDef extends IsValDefExtractor {
115+
object IsValDef extends IsValDefModule {
116116
def unapply(tree: Tree)(implicit ctx: Context): Option[ValDef] = tree match {
117117
case x: tpd.ValDef => Some(x)
118118
case _ => None
@@ -135,7 +135,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
135135

136136
// TypeDef
137137

138-
object IsTypeDef extends IsTypeDefExtractor {
138+
object IsTypeDef extends IsTypeDefModule {
139139
def unapply(tree: Tree)(implicit ctx: Context): Option[TypeDef] = tree match {
140140
case x: tpd.TypeDef if !x.symbol.isClass => Some(x)
141141
case _ => None
@@ -168,7 +168,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
168168
def symbol(implicit ctx: Context): PackageSymbol = pdef.symbol
169169
}
170170

171-
object IsPackageDef extends IsPackageDefExtractor {
171+
object IsPackageDef extends IsPackageDefModule {
172172
def unapply(tree: Tree)(implicit ctx: Context): Option[PackageDef] = tree match {
173173
case x: PackageDefinition => Some(x)
174174
case _ => None
@@ -193,7 +193,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
193193
def underlying(implicit ctx: Context): Term = term.underlying
194194
}
195195

196-
object IsTerm extends IsTermExtractor {
196+
object IsTerm extends IsTermModule {
197197
def unapply(tree: Tree)(implicit ctx: Context): Option[Term] =
198198
if (tree.isTerm) Some(tree) else None
199199
def unapply(termOrTypeTree: TermOrTypeTree)(implicit ctx: Context, dummy: DummyImplicit): Option[Term] =
@@ -202,13 +202,27 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
202202

203203
object Term extends TermModule with TermCoreModuleImpl {
204204

205+
object IsIdent extends IsIdentModule {
206+
def unapply(x: Term)(implicit ctx: Context): Option[Ident] = x match {
207+
case x: tpd.Ident if x.isTerm => Some(x)
208+
case _ => None
209+
}
210+
}
211+
205212
object Ident extends IdentExtractor {
206213
def unapply(x: Term)(implicit ctx: Context): Option[String] = x match {
207214
case x: tpd.Ident if x.isTerm => Some(x.name.show)
208215
case _ => None
209216
}
210217
}
211218

219+
object IsSelect extends IsSelectModule {
220+
def unapply(x: Term)(implicit ctx: Context): Option[Select] = x match {
221+
case x: tpd.Select if x.isTerm => Some(x)
222+
case _ => None
223+
}
224+
}
225+
212226
object Select extends SelectExtractor {
213227
def unapply(x: Term)(implicit ctx: Context): Option[(Term, String, Option[Signature])] = x match {
214228
case x: tpd.Select if x.isTerm =>
@@ -220,69 +234,139 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
220234
}
221235
}
222236

237+
object IsLiteral extends IsLiteralModule {
238+
def unapply(x: Term)(implicit ctx: Context): Option[Literal] = x match {
239+
case x: tpd.Literal => Some(x)
240+
case _ => None
241+
}
242+
}
243+
223244
object Literal extends LiteralExtractor {
224245
def unapply(x: Term)(implicit ctx: Context): Option[Constant] = x match {
225246
case Trees.Literal(const) => Some(const)
226247
case _ => None
227248
}
228249
}
229250

251+
object IsThis extends IsThisModule {
252+
def unapply(x: Term)(implicit ctx: Context): Option[This] = x match {
253+
case x: tpd.This => Some(x)
254+
case _ => None
255+
}
256+
}
257+
230258
object This extends ThisExtractor {
231259
def unapply(x: Term)(implicit ctx: Context): Option[Option[Id]] = x match {
232260
case Trees.This(qual) => Some(optional(qual))
233261
case _ => None
234262
}
235263
}
236264

265+
object IsNew extends IsNewModule {
266+
def unapply(x: Term)(implicit ctx: Context): Option[New] = x match {
267+
case x: tpd.New => Some(x)
268+
case _ => None
269+
}
270+
}
271+
237272
object New extends NewExtractor {
238273
def unapply(x: Term)(implicit ctx: Context): Option[TypeTree] = x match {
239274
case x: tpd.New => Some(x.tpt)
240275
case _ => None
241276
}
242277
}
243278

279+
object IsNamedArg extends IsNamedArgModule {
280+
def unapply(x: Term)(implicit ctx: Context): Option[NamedArg] = x match {
281+
case x: tpd.NamedArg if x.name.isInstanceOf[Names.TermName] => Some(x) // TODO: Now, the name should alwas be a term name
282+
case _ => None
283+
}
284+
}
285+
244286
object NamedArg extends NamedArgExtractor {
245287
def unapply(x: Term)(implicit ctx: Context): Option[(String, Term)] = x match {
246288
case x: tpd.NamedArg if x.name.isInstanceOf[Names.TermName] => Some((x.name.toString, x.arg))
247289
case _ => None
248290
}
249291
}
250292

293+
object IsApply extends IsApplyModule {
294+
def unapply(x: Term)(implicit ctx: Context): Option[Apply] = x match {
295+
case x: tpd.Apply => Some(x)
296+
case _ => None
297+
}
298+
}
299+
251300
object Apply extends ApplyExtractor {
252301
def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[Term])] = x match {
253302
case x: tpd.Apply => Some((x.fun, x.args))
254303
case _ => None
255304
}
256305
}
257306

307+
object IsTypeApply extends IsTypeApplyModule {
308+
def unapply(x: Term)(implicit ctx: Context): Option[TypeApply] = x match {
309+
case x: tpd.TypeApply => Some(x)
310+
case _ => None
311+
}
312+
}
313+
258314
object TypeApply extends TypeApplyExtractor {
259315
def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[TypeTree])] = x match {
260316
case x: tpd.TypeApply => Some((x.fun, x.args))
261317
case _ => None
262318
}
263319
}
264320

321+
object IsSuper extends IsSuperModule {
322+
def unapply(x: Term)(implicit ctx: Context): Option[Super] = x match {
323+
case x: tpd.Super => Some(x)
324+
case _ => None
325+
}
326+
}
327+
265328
object Super extends SuperExtractor {
266329
def unapply(x: Term)(implicit ctx: Context): Option[(Term, Option[Id])] = x match {
267330
case x: tpd.Super => Some((x.qual, if (x.mix.isEmpty) None else Some(x.mix)))
268331
case _ => None
269332
}
270333
}
271334

335+
object IsTyped extends IsTypedModule {
336+
def unapply(x: Term)(implicit ctx: Context): Option[Typed] = x match {
337+
case x: tpd.Typed => Some(x)
338+
case _ => None
339+
}
340+
}
341+
272342
object Typed extends TypedExtractor {
273343
def unapply(x: Term)(implicit ctx: Context): Option[(Term, TypeTree)] = x match {
274344
case x: tpd.Typed => Some((x.expr, x.tpt))
275345
case _ => None
276346
}
277347
}
278348

349+
object IsAssign extends IsAssignModule {
350+
def unapply(x: Term)(implicit ctx: Context): Option[Assign] = x match {
351+
case x: tpd.Assign => Some(x)
352+
case _ => None
353+
}
354+
}
355+
279356
object Assign extends AssignExtractor {
280357
def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {
281358
case x: tpd.Assign => Some((x.lhs, x.rhs))
282359
case _ => None
283360
}
284361
}
285362

363+
object IsBlock extends IsBlockModule {
364+
def unapply(x: Term)(implicit ctx: Context): Option[Block] = Block.normalizedLoops(x) match {
365+
case x: tpd.Block => Some(x)
366+
case _ => None
367+
}
368+
}
369+
286370
object Block extends BlockExtractor {
287371
def unapply(x: Term)(implicit ctx: Context): Option[(List[Statement], Term)] = normalizedLoops(x) match {
288372
case Trees.Block(stats, expr) => Some((stats, expr))
@@ -292,7 +376,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
292376
* i) Put `while` and `doWhile` loops in their own blocks: `{ def while$() = ...; while$() }`
293377
* ii) Put closures in their own blocks: `{ def anon$() = ...; closure(anon$, ...) }`
294378
*/
295-
private def normalizedLoops(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
379+
private[Term] def normalizedLoops(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
296380
case block: tpd.Block if block.stats.size > 1 =>
297381
def normalizeInnerLoops(stats: List[tpd.Tree]): List[tpd.Tree] = stats match {
298382
case (x: tpd.DefDef) :: y :: xs if needsNormalization(y) =>
@@ -318,6 +402,13 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
318402
}
319403
}
320404

405+
object IsInlined extends IsInlinedModule {
406+
def unapply(x: Term)(implicit ctx: Context): Option[Inlined] = x match {
407+
case x: tpd.Inlined => Some(x)
408+
case _ => None
409+
}
410+
}
411+
321412
object Inlined extends InlinedExtractor {
322413
def unapply(x: Term)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Statement], Term)] = x match {
323414
case x: tpd.Inlined =>
@@ -326,48 +417,101 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
326417
}
327418
}
328419

420+
object IsLambda extends IsLambdaModule {
421+
def unapply(x: Term)(implicit ctx: Context): Option[Lambda] = x match {
422+
case x: tpd.Closure => Some(x)
423+
case _ => None
424+
}
425+
}
426+
329427
object Lambda extends LambdaExtractor {
330428
def unapply(x: Term)(implicit ctx: Context): Option[(Term, Option[TypeTree])] = x match {
331429
case x: tpd.Closure => Some((x.meth, optional(x.tpt)))
332430
case _ => None
333431
}
334432
}
335433

434+
object IsIf extends IsIfModule {
435+
def unapply(x: Term)(implicit ctx: Context): Option[If] = x match {
436+
case x: tpd.If => Some(x)
437+
case _ => None
438+
}
439+
}
440+
336441
object If extends IfExtractor {
337442
def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term, Term)] = x match {
338443
case x: tpd.If => Some((x.cond, x.thenp, x.elsep))
339444
case _ => None
340445
}
341446
}
342447

448+
object IsMatch extends IsMatchModule {
449+
def unapply(x: Term)(implicit ctx: Context): Option[Match] = x match {
450+
case x: tpd.Match => Some(x)
451+
case _ => None
452+
}
453+
}
454+
343455
object Match extends MatchExtractor {
344456
def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[CaseDef])] = x match {
345457
case x: tpd.Match => Some((x.selector, x.cases))
346458
case _ => None
347459
}
348460
}
349461

462+
object IsTry extends IsTryModule {
463+
def unapply(x: Term)(implicit ctx: Context): Option[Try] = x match {
464+
case x: tpd.Try => Some(x)
465+
case _ => None
466+
}
467+
}
468+
350469
object Try extends TryExtractor {
351470
def unapply(x: Term)(implicit ctx: Context): Option[(Term, List[CaseDef], Option[Term])] = x match {
352471
case x: tpd.Try => Some((x.expr, x.cases, optional(x.finalizer)))
353472
case _ => None
354473
}
355474
}
356475

476+
object IsReturn extends IsReturnModule {
477+
def unapply(x: Term)(implicit ctx: Context): Option[Return] = x match {
478+
case x: tpd.Return => Some(x)
479+
case _ => None
480+
}
481+
}
482+
357483
object Return extends ReturnExtractor {
358484
def unapply(x: Term)(implicit ctx: Context): Option[Term] = x match {
359485
case x: tpd.Return => Some(x.expr)
360486
case _ => None
361487
}
362488
}
363489

490+
object IsRepeated extends IsRepeatedModule {
491+
def unapply(x: Term)(implicit ctx: Context): Option[Repeated] = x match {
492+
case x: tpd.SeqLiteral => Some(x)
493+
case _ => None
494+
}
495+
}
496+
364497
object Repeated extends RepeatedExtractor {
365498
def unapply(x: Term)(implicit ctx: Context): Option[List[Term]] = x match {
366499
case x: tpd.SeqLiteral => Some(x.elems)
367500
case _ => None
368501
}
369502
}
370503

504+
object IsSelectOuter extends IsSelectOuterModule {
505+
def unapply(x: Term)(implicit ctx: Context): Option[SelectOuter] = x match {
506+
case x: tpd.Select =>
507+
x.name match {
508+
case NameKinds.OuterSelectName(_, _) => Some(x)
509+
case _ => None
510+
}
511+
case _ => None
512+
}
513+
}
514+
371515
object SelectOuter extends SelectOuterExtractor {
372516
def unapply(x: Term)(implicit ctx: Context): Option[(Term, Int, Type)] = x match {
373517
case x: tpd.Select =>
@@ -379,6 +523,13 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
379523
}
380524
}
381525

526+
object IsWhile extends IsWhileModule {
527+
def unapply(x: Term)(implicit ctx: Context): Option[While] = x match {
528+
case x: tpd.WhileDo => Some(x)
529+
case _ => None
530+
}
531+
}
532+
382533
object While extends WhileExtractor {
383534
def unapply(x: Term)(implicit ctx: Context): Option[(Term, Term)] = x match {
384535
case x: tpd.WhileDo => Some((x.cond, x.body))

‎library/src/scala/tasty/reflect/TreeOps.scala

Lines changed: 78 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -11,8 +11,8 @@ trait TreeOps extends Core {
1111
}
1212
implicit def TreeDeco(tree: Tree): TreeAPI
1313

14-
val IsPackageClause: IsPackageClauseExtractor
15-
abstract class IsPackageClauseExtractor {
14+
val IsPackageClause: IsPackageClauseModule
15+
abstract class IsPackageClauseModule {
1616
def unapply(tree: Tree)(implicit ctx: Context): Option[PackageClause]
1717
}
1818

@@ -41,8 +41,8 @@ trait TreeOps extends Core {
4141

4242
// ----- Definitions ----------------------------------------------
4343

44-
val IsDefinition: IsDefinitionExtractor
45-
abstract class IsDefinitionExtractor {
44+
val IsDefinition: IsDefinitionModule
45+
abstract class IsDefinitionModule {
4646
def unapply(tree: Tree)(implicit ctx: Context): Option[Definition]
4747
}
4848

@@ -53,8 +53,8 @@ trait TreeOps extends Core {
5353

5454
// ClassDef
5555

56-
val IsClassDef: IsClassDefExtractor
57-
abstract class IsClassDefExtractor {
56+
val IsClassDef: IsClassDefModule
57+
abstract class IsClassDefModule {
5858
def unapply(tree: Tree)(implicit ctx: Context): Option[ClassDef]
5959
}
6060

@@ -75,8 +75,8 @@ trait TreeOps extends Core {
7575

7676
// DefDef
7777

78-
val IsDefDef: IsDefDefExtractor
79-
abstract class IsDefDefExtractor {
78+
val IsDefDef: IsDefDefModule
79+
abstract class IsDefDefModule {
8080
def unapply(tree: Tree)(implicit ctx: Context): Option[DefDef]
8181
}
8282

@@ -97,8 +97,8 @@ trait TreeOps extends Core {
9797

9898
// ValDef
9999

100-
val IsValDef: IsValDefExtractor
101-
abstract class IsValDefExtractor {
100+
val IsValDef: IsValDefModule
101+
abstract class IsValDefModule {
102102
def unapply(tree: Tree)(implicit ctx: Context): Option[ValDef]
103103
}
104104

@@ -117,8 +117,8 @@ trait TreeOps extends Core {
117117

118118
// TypeDef
119119

120-
val IsTypeDef: IsTypeDefExtractor
121-
abstract class IsTypeDefExtractor {
120+
val IsTypeDef: IsTypeDefModule
121+
abstract class IsTypeDefModule {
122122
def unapply(tree: Tree)(implicit ctx: Context): Option[TypeDef]
123123
}
124124

@@ -135,8 +135,8 @@ trait TreeOps extends Core {
135135

136136
// PackageDef
137137

138-
val IsPackageDef: IsPackageDefExtractor
139-
abstract class IsPackageDefExtractor {
138+
val IsPackageDef: IsPackageDefModule
139+
abstract class IsPackageDefModule {
140140
def unapply(tree: Tree)(implicit ctx: Context): Option[PackageDef]
141141
}
142142

@@ -162,8 +162,8 @@ trait TreeOps extends Core {
162162
}
163163
implicit def TermDeco(term: Term): TermAPI
164164

165-
val IsTerm: IsTermExtractor
166-
abstract class IsTermExtractor {
165+
val IsTerm: IsTermModule
166+
abstract class IsTermModule {
167167
/** Matches any term */
168168
def unapply(tree: Tree)(implicit ctx: Context): Option[Term]
169169
/** Matches any term */
@@ -174,8 +174,8 @@ trait TreeOps extends Core {
174174
val Term: TermModule
175175
abstract class TermModule extends TermCoreModule {
176176

177-
val Ident: IsIdentExtractor
178-
abstract class IsIdentExtractor {
177+
val IsIdent: IsIdentModule
178+
abstract class IsIdentModule {
179179
/** Matches any Ident and returns it */
180180
def unapply(tree: Tree)(implicit ctx: Context): Option[Ident]
181181
}
@@ -187,8 +187,8 @@ trait TreeOps extends Core {
187187
def unapply(tree: Tree)(implicit ctx: Context): Option[String]
188188
}
189189

190-
val Select: IsSelectExtractor
191-
abstract class IsSelectExtractor {
190+
val IsSelect: IsSelectModule
191+
abstract class IsSelectModule {
192192
/** Matches any Select and returns it */
193193
def unapply(tree: Tree)(implicit ctx: Context): Option[Select]
194194
}
@@ -200,8 +200,8 @@ trait TreeOps extends Core {
200200
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String, Option[Signature])]
201201
}
202202

203-
val Literal: IsLiteralExtractor
204-
abstract class IsLiteralExtractor {
203+
val IsLiteral: IsLiteralModule
204+
abstract class IsLiteralModule {
205205
/** Matches any Literal and returns it */
206206
def unapply(tree: Tree)(implicit ctx: Context): Option[Literal]
207207
}
@@ -212,8 +212,8 @@ trait TreeOps extends Core {
212212
def unapply(tree: Tree)(implicit ctx: Context): Option[Constant]
213213
}
214214

215-
val This: IsThisExtractor
216-
abstract class IsThisExtractor {
215+
val IsThis: IsThisModule
216+
abstract class IsThisModule {
217217
/** Matches any This and returns it */
218218
def unapply(tree: Tree)(implicit ctx: Context): Option[This]
219219
}
@@ -225,8 +225,8 @@ trait TreeOps extends Core {
225225
def unapply(tree: Tree)(implicit ctx: Context): Option[Option[Id]]
226226
}
227227

228-
val New: IsNewExtractor
229-
abstract class IsNewExtractor {
228+
val IsNew: IsNewModule
229+
abstract class IsNewModule {
230230
/** Matches any New and returns it */
231231
def unapply(tree: Tree)(implicit ctx: Context): Option[New]
232232
}
@@ -238,8 +238,8 @@ trait TreeOps extends Core {
238238
def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree]
239239
}
240240

241-
val NamedArg: IsNamedArgExtractor
242-
abstract class IsNamedArgExtractor {
241+
val IsNamedArg: IsNamedArgModule
242+
abstract class IsNamedArgModule {
243243
/** Matches any NamedArg and returns it */
244244
def unapply(tree: Tree)(implicit ctx: Context): Option[NamedArg]
245245
}
@@ -251,8 +251,8 @@ trait TreeOps extends Core {
251251
def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Term)]
252252
}
253253

254-
val Apply: IsApplyExtractor
255-
abstract class IsApplyExtractor {
254+
val IsApply: IsApplyModule
255+
abstract class IsApplyModule {
256256
/** Matches any Apply and returns it */
257257
def unapply(tree: Tree)(implicit ctx: Context): Option[Apply]
258258
}
@@ -264,8 +264,8 @@ trait TreeOps extends Core {
264264
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[Term])]
265265
}
266266

267-
val TypeApply: IsTypeApplyExtractor
268-
abstract class IsTypeApplyExtractor {
267+
val IsTypeApply: IsTypeApplyModule
268+
abstract class IsTypeApplyModule {
269269
/** Matches any TypeApply and returns it */
270270
def unapply(tree: Tree)(implicit ctx: Context): Option[TypeApply]
271271
}
@@ -277,8 +277,8 @@ trait TreeOps extends Core {
277277
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[TypeTree])]
278278
}
279279

280-
val Super: IsSuperExtractor
281-
abstract class IsSuperExtractor {
280+
val IsSuper: IsSuperModule
281+
abstract class IsSuperModule {
282282
/** Matches any Super and returns it */
283283
def unapply(tree: Tree)(implicit ctx: Context): Option[Super]
284284
}
@@ -290,8 +290,8 @@ trait TreeOps extends Core {
290290
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[Id])]
291291
}
292292

293-
val Typed: IsTypedExtractor
294-
abstract class IsTypedExtractor {
293+
val IsTyped: IsTypedModule
294+
abstract class IsTypedModule {
295295
/** Matches any Typed and returns it */
296296
def unapply(tree: Tree)(implicit ctx: Context): Option[Typed]
297297
}
@@ -303,8 +303,8 @@ trait TreeOps extends Core {
303303
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, TypeTree)]
304304
}
305305

306-
val Assign: IsAssignExtractor
307-
abstract class IsAssignExtractor {
306+
val IsAssign: IsAssignModule
307+
abstract class IsAssignModule {
308308
/** Matches any Assign and returns it */
309309
def unapply(tree: Tree)(implicit ctx: Context): Option[Assign]
310310
}
@@ -316,8 +316,8 @@ trait TreeOps extends Core {
316316
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]
317317
}
318318

319-
val Block: IsBlockExtractor
320-
abstract class IsBlockExtractor {
319+
val IsBlock: IsBlockModule
320+
abstract class IsBlockModule {
321321
/** Matches any Block and returns it */
322322
def unapply(tree: Tree)(implicit ctx: Context): Option[Block]
323323
}
@@ -329,15 +329,21 @@ trait TreeOps extends Core {
329329
def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Statement], Term)]
330330
}
331331

332+
val IsLambda: IsLambdaModule
333+
abstract class IsLambdaModule {
334+
/** Matches any Lambda and returns it */
335+
def unapply(tree: Tree)(implicit ctx: Context): Option[Lambda]
336+
}
337+
332338
val Lambda: LambdaExtractor
333339
abstract class LambdaExtractor {
334340
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[TypeTree])]
335341
}
336342

337-
val XYZ: IsXYZExtractor
338-
abstract class IsXYZExtractor {
339-
/** Matches any XYZ and returns it */
340-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
343+
val IsIf: IsIfModule
344+
abstract class IsIfModule {
345+
/** Matches any If and returns it */
346+
def unapply(tree: Tree)(implicit ctx: Context): Option[If]
341347
}
342348

343349
/** Scala `if`/`else` term */
@@ -347,10 +353,10 @@ trait TreeOps extends Core {
347353
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term, Term)]
348354
}
349355

350-
val XYZ: IsXYZExtractor
351-
abstract class IsXYZExtractor {
352-
/** Matches any XYZ and returns it */
353-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
356+
val IsMatch: IsMatchModule
357+
abstract class IsMatchModule {
358+
/** Matches any Match and returns it */
359+
def unapply(tree: Tree)(implicit ctx: Context): Option[Match]
354360
}
355361

356362
/** Scala `match` term */
@@ -360,10 +366,10 @@ trait TreeOps extends Core {
360366
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef])]
361367
}
362368

363-
val XYZ: IsXYZExtractor
364-
abstract class IsXYZExtractor {
365-
/** Matches any XYZ and returns it */
366-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
369+
val IsTry: IsTryModule
370+
abstract class IsTryModule {
371+
/** Matches any Try and returns it */
372+
def unapply(tree: Tree)(implicit ctx: Context): Option[Try]
367373
}
368374

369375
/** Scala `try`/`catch`/`finally` term */
@@ -373,10 +379,10 @@ trait TreeOps extends Core {
373379
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef], Option[Term])]
374380
}
375381

376-
val XYZ: IsXYZExtractor
377-
abstract class IsXYZExtractor {
378-
/** Matches any XYZ and returns it */
379-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
382+
val IsReturn: IsReturnModule
383+
abstract class IsReturnModule {
384+
/** Matches any Return and returns it */
385+
def unapply(tree: Tree)(implicit ctx: Context): Option[Return]
380386
}
381387

382388
/** Scala local `return` */
@@ -386,43 +392,43 @@ trait TreeOps extends Core {
386392
def unapply(tree: Tree)(implicit ctx: Context): Option[Term]
387393
}
388394

389-
val XYZ: IsXYZExtractor
390-
abstract class IsXYZExtractor {
391-
/** Matches any XYZ and returns it */
392-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
395+
val IsRepeated: IsRepeatedModule
396+
abstract class IsRepeatedModule {
397+
/** Matches any Repeated and returns it */
398+
def unapply(tree: Tree)(implicit ctx: Context): Option[Repeated]
393399
}
394400

395401
val Repeated: RepeatedExtractor
396402
abstract class RepeatedExtractor {
397403
def unapply(tree: Tree)(implicit ctx: Context): Option[List[Term]]
398404
}
399405

400-
val XYZ: IsXYZExtractor
401-
abstract class IsXYZExtractor {
402-
/** Matches any XYZ and returns it */
403-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
406+
val IsInlined: IsInlinedModule
407+
abstract class IsInlinedModule {
408+
/** Matches any Inlined and returns it */
409+
def unapply(tree: Tree)(implicit ctx: Context): Option[Inlined]
404410
}
405411

406412
val Inlined: InlinedExtractor
407413
abstract class InlinedExtractor {
408414
def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TermOrTypeTree], List[Definition], Term)]
409415
}
410416

411-
val XYZ: IsXYZExtractor
412-
abstract class IsXYZExtractor {
413-
/** Matches any XYZ and returns it */
414-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
417+
val IsSelectOuter: IsSelectOuterModule
418+
abstract class IsSelectOuterModule {
419+
/** Matches any SelectOuter and returns it */
420+
def unapply(tree: Tree)(implicit ctx: Context): Option[SelectOuter]
415421
}
416422

417423
val SelectOuter: SelectOuterExtractor
418424
abstract class SelectOuterExtractor {
419425
def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Int, Type)]
420426
}
421427

422-
val XYZ: IsXYZExtractor
423-
abstract class IsXYZExtractor {
424-
/** Matches any XYZ and returns it */
425-
def unapply(tree: Tree)(implicit ctx: Context): Option[XYZ]
428+
val IsWhile: IsWhileModule
429+
abstract class IsWhileModule {
430+
/** Matches any While and returns it */
431+
def unapply(tree: Tree)(implicit ctx: Context): Option[While]
426432
}
427433

428434
val While: WhileExtractor

0 commit comments

Comments
 (0)
Please sign in to comment.