How tot define wildcard patterns in 3.0.x

[dduquesne]

Compiler version

3.0.0 RC3

Minimized example

			/*
			'sel' is an 'Expr' returning an 'Int'.
			We need to convert this 'Expr' into a 'Tree' subtype.
			In our context, 'sel' is a 'Term'.
			'sel' will be the selector for the match expression we want to synthetize.
			*/
			val selector = sel.asTerm

			/*
			We need a sequence of case block statement to synthetize the match block expression.
			We want to use the array parameter to define this sequence dynamicaly at runtime.
			We use the 'map' method to create this case sequence by itterating over the array 'arr'.
			Each itteration produce a 'CaseDef' instance.
			QUESTION ??? : How to use WildcardTypeTreeModule to implemnt the default 'CaseDef'.
			*/
			val dynCases: List[CaseDef] = arr.toList.map{ i =>
				/*
				CaseDef statement :
				- Pattern : Match an array element x (as a literal).
				- Guard : Expect an 'Option'. Use 'None' as we don't use this feature.
				- RHS : return 'x + 1' as an 'Int'. x is the array element used to create the above pattern.
				'IntConstant' is a subtype of 'Constant'
				'Literal' produce a 'Term' from a 'Constant'
				*/
				val pattern = Literal(IntConstant(i))
				val guard = None
				val rhs = Literal(IntConstant(333))
				// Literal(IntConstant(333)))
				// Literal(IntConstant(i + 1))
				CaseDef(pattern, guard, rhs)
			}


			//val defaultPattern = Literal(IntConstant(10))
			//val defaultPattern = Ident(_).underlying()
			//val defaultPattern : Tree = Ident(Symbol("_")).asInstanceOf[Tree]
			//val defaultPattern: Tree = Ident(TermRef(TypeRepr.of[Any],"_")).asInstanceOf[Tree]
			//val defaultPattern: Tree = Ident("_")
			//val defaultPattern = Literal(IntConstant(10))
			//val wildcard = Symbol.newVal(Symbol.noSymbol, "_", TypeRepr.of[fontInt], Flags.EmptyFlags, Symbol.noSymbol)
			//val defaultPattern = Typed(Ident(TermRef(TypeRepr.of[Int], "_")), TypeIdent(Symbol.classSymbol("scala.Int"))).asInstanceOf[Tree]
			//Ident(wildcard)
			val defaultPattern = Typed('{_:Int}.asTerm, TypeIdent(Symbol.classSymbol("scala.Int"))).asInstanceOf[Tree]
			val defaultGuard = None
			val defaultRhs = Literal(IntConstant(10))
			//val defaultRhs = Block( List( ValDef( Symbol.newVal( Symbol.noSymbol,"y",TypeRepr.of[Int],Flags.EmptyFlags,Symbol.noSymbol), Some( Literal( IntConstant( 40))))), Typed.apply( TermRef.apply( TypeRepr.of[Int], "y" ).asInstanceOf[Term] , TypeTree.of[Int] ) )

			val defaultCase = List(CaseDef(defaultPattern, defaultGuard, defaultRhs))
			val cases = dynCases ::: defaultCase


			/*
			We can now build the match expression using the selector and the case sequence.
			We do that using TASTY low level API ('Tree' object).
			Then we convert into higher level 'Expr' returning an 'Int'.
			This 'Expr' is the function return.
			*/ 

			Match(selector, cases).asExprOf[Int]

Expectation

Hello,
I am trying to synthetize a pattern match expression using reflect.
I need the default case _
I am looking into https://github.com/lampepfl/dotty/blob/master/library/src/scala/quoted/Quotes.scala
I see a CaseDef module expecting a Tree as a pattern.
I can create a basic pattern with Literral.
But i do not find any way to use the default/wildcard pattern :

trait CaseDefModule { this: CaseDef.type => def apply(pattern: Tree, guard: Option[Term], rhs: Term): CaseDef

Do you have any idea how the default case could be implemented ?
Thank for your help.

[nicolasstucki]

We need a wildcard but that is blocked by issue #12200.

The solution for now is to add a Bind pattern as las pattern that binds to anything and just ignore the binding.

case x => 
// Instead of 
case _ =>

[nicolasstucki]

Here is an example #12237 (comment)

[dduquesne]

Hello @nicolasstucki
Thank a lot for your feedback.
By using this piece of code below :

            val intTypeTree = TypeTree.of[Int]
            val bind = Symbol.newBind(Symbol.spliceOwner, "_", Flags.EmptyFlags, intTypeTree.tpe)
            val defaultPattern = Bind(bind, Typed(Ref(bind),intTypeTree))
            val defaultGuard = None
            val defaultRhs = Literal(IntConstant(10))
            val defaultCase = List(CaseDef(defaultPattern, defaultGuard, defaultRhs))

I can generate and execute this below code at runtime

### GENERATED CODE ###
((x: scala.Int) => x match {
case 1 =>
333
case 2 =>
333
case _: scala.Int =>
10
})
######################

The last casedef works as a default one.

I went to the other discussion and i have to admit that i have the same issue trying to understand Ref , Ident and Select.
It's a bit more clear now but i do not feel confident.
I am not sure to understand completely the semantic.
I have the same issue with

+- TypeRepr -+- NamedType -+- TermRef
+- TypeRef

I see we can use Symbol to represent langage token used in deffinition ( val, var, def ).
It seems we can use them also for classe and package.

But not for type ? And then we need TypeRepr and TypeRef instead ? But what is the point of TermRef.

I am trying to write concrete example like below for each module in the low level API :
Typed => x: T
Ident => val titi: Int = 3; val toto: Int = titi

Thank for your help and explanation.