use new wildcard syntax

cli/src/main/scala/scalaxb/compiler/Module.scala

@@ -486,7 +486,7 @@ trait Module {
       case EntityRef("lt")  => out.print('<')
       case EntityRef("gt")  => out.print('>')
       case EntityRef("amp") => out.print('&')
-      case atom: Atom[_]    => out.print(transform(atom.text))
+      case atom: Atom[?]    => out.print(transform(atom.text))
       case elem: Elem       =>
         printNodes(elem.child, out, transform)
         if (elem.text != "") {

cli/src/main/scala/scalaxb/compiler/xsd/ContentModelDecl.scala

@@ -30,7 +30,7 @@ trait ComplexTypeContent {
 abstract class ContentTypeDecl extends Decl
 
 case class SimpContRestrictionDecl(base: XsTypeSymbol, simpleType: Option[XsTypeSymbol],
-  facets: List[Facetable[_]],
+  facets: List[Facetable[?]],
   attributes: List[AttributeLike]) extends ContentTypeDecl with ComplexTypeContent
 
 object SimpContRestrictionDecl {
@@ -144,7 +144,7 @@ object CompContExtensionDecl {
   }  
 }
 
-case class SimpTypRestrictionDecl(base: XsTypeSymbol, facets: List[Facetable[_]]) extends ContentTypeDecl
+case class SimpTypRestrictionDecl(base: XsTypeSymbol, facets: List[Facetable[?]]) extends ContentTypeDecl
 
 object SimpTypRestrictionDecl {  
   def fromXML(node: scala.xml.Node, family: List[String], config: ParserConfig) = {
@@ -204,7 +204,7 @@ trait Facetable[A] {
 }
 
 object Facetable {
-  def fromParent(node: scala.xml.Node, base: XsTypeSymbol, config: ParserConfig): List[Facetable[_]] = 
+  def fromParent(node: scala.xml.Node, base: XsTypeSymbol, config: ParserConfig): List[Facetable[?]] = 
     node.child.toList collect {
       case x if x.label == "enumeration" => EnumerationDecl.fromXML(x, base, config)
     }

cli/src/main/scala/scalaxb/compiler/xsd/ContextProcessor.scala

@@ -71,7 +71,7 @@ trait ContextProcessor extends ScalaNames with PackageName {
 
     (None :: (config.packageNames.valuesIterator.toList.distinct)) map {
       pkg =>
-        context.enumValueNames(pkg) = mutable.ListMap.empty[(String, EnumerationDecl[_]), String]
+        context.enumValueNames(pkg) = mutable.ListMap.empty[(String, EnumerationDecl[?]), String]
     }
 
     val anonymousTypes = mutable.ListBuffer.empty[(SchemaDecl, ComplexTypeDecl)]
@@ -298,18 +298,18 @@ trait ContextProcessor extends ScalaNames with PackageName {
   def containsEnumeration(decl: SimpleTypeDecl) = decl.content match {
     case x: SimpTypRestrictionDecl =>
       x.facets exists { f => f match {
-          case e: EnumerationDecl[_] => true
+          case e: EnumerationDecl[?] => true
           case _ => false
         }
       }
 
     case _ => false
   }
 
-  def filterEnumeration(decl: SimpleTypeDecl): List[EnumerationDecl[_]] = decl.content match {
+  def filterEnumeration(decl: SimpleTypeDecl): List[EnumerationDecl[?]] = decl.content match {
     case x: SimpTypRestrictionDecl =>
       x.facets collect {
-        case e: EnumerationDecl[_] => e
+        case e: EnumerationDecl[?] => e
       }
 
     case _ => Nil

cli/src/main/scala/scalaxb/compiler/xsd/Decl.scala

@@ -42,7 +42,7 @@ case class XsdContext(
   schemas: mutable.ListBuffer[SchemaDecl] = mutable.ListBuffer(),
   typeNames: mutable.ListMap[NameKey, String] = mutable.ListMap(),
   enumValueNames: mutable.ListMap[Option[String],
-      mutable.ListMap[(String, EnumerationDecl[_]), String]] = mutable.ListMap(),
+      mutable.ListMap[(String, EnumerationDecl[?]), String]] = mutable.ListMap(),
   packageNames: mutable.ListMap[Option[String], Option[String]] = mutable.ListMap(),
   complexTypes: mutable.ListBuffer[(SchemaDecl, ComplexTypeDecl)] = mutable.ListBuffer(),
   baseToSubs: mutable.ListMap[ComplexTypeDecl, List[ComplexTypeDecl]] = mutable.ListMap(),

cli/src/main/scala/scalaxb/compiler/xsd/GenSource.scala

@@ -618,11 +618,11 @@ class GenSource(val schema: SchemaDecl,
     val baseSym : Option[XsTypeSymbol] = decl.content match {case SimpTypRestrictionDecl(base, _) => Some(base) case _ => None}
     val baseType: Option[String      ] = baseSym.map(buildTypeName(_))
 
-    def makeEnum(enumDecl: EnumerationDecl[_]) =
+    def makeEnum(enumDecl: EnumerationDecl[?]) =
       "case object " + buildTypeName(localName, enumDecl, true) + " extends " + localName + 
       " { override def toString = " + quote(enumDecl.value.toString) + " }"
 
-    def makeCaseEntry(enumDecl: EnumerationDecl[_]) = baseSym match {
+    def makeCaseEntry(enumDecl: EnumerationDecl[?]) = baseSym match {
       case Some(XsQName) => s"${indent(3)}case ${quote(enumDecl.value.toString)} => ${buildTypeName(localName, enumDecl, false)}\n"
       case _ => baseType.map {tpe =>
         s"${indent(3)}case x: $tpe if x == scalaxb.fromXML[$tpe](scala.xml.Text(${quote(enumDecl.value.toString)})) => ${buildTypeName(localName, enumDecl, false)}\n"
@@ -663,7 +663,7 @@ object {localName} {{
 { enumString }</source>
     }  // match
 
-    def enumMatchGroup(enums: List[EnumerationDecl[_]], index: Int): String = {
+    def enumMatchGroup(enums: List[EnumerationDecl[?]], index: Int): String = {
       s"""    private def fromString$index(value: String, scope: scala.xml.NamespaceBinding): PartialFunction[Any, $fqn] = {
          |${enums.map(e => makeCaseEntry(e)).mkString}
          |    }

cli/src/main/scala/scalaxb/compiler/xsd/Lookup.scala

@@ -179,7 +179,7 @@ trait Lookup extends ContextProcessor {
   def buildTypeName(group: AttributeGroupDecl, shortLocal: Boolean): String =
     buildTypeName(packageName(group, context), group, shortLocal)
 
-  def buildTypeName(enumTypeName: String, enumDecl: EnumerationDecl[_], shortLocal: Boolean): String = {
+  def buildTypeName(enumTypeName: String, enumDecl: EnumerationDecl[?], shortLocal: Boolean): String = {
     val pkg = packageName(schema, context)
     val typeNames = context.enumValueNames(pkg)
     if (!typeNames.contains(enumTypeName, enumDecl))

cli/src_managed/scalaxb/scalaxb.scala

@@ -380,10 +380,10 @@ object DataRecord extends XMLStandardTypes {
     xstypeNamespace: Option[String],
     xstypeName: Option[String],
     value: A,
-    writer: CanWriteXML[_]) extends DataRecord[A] {
+    writer: CanWriteXML[?]) extends DataRecord[A] {
     override def equals(o: Any): Boolean =
       o match {
-        case that: DataWriter[_] =>
+        case that: DataWriter[?] =>
           namespace == that.namespace &&
           key == that.key &&
           value == that.value
@@ -573,7 +573,7 @@ object DataRecord extends XMLStandardTypes {
 
   def toXML[A](obj: DataRecord[A], namespace: Option[String], elementLabel: Option[String],
       scope: scala.xml.NamespaceBinding, typeAttribute: Boolean): scala.xml.NodeSeq = obj match {
-    case w: DataWriter[_] =>
+    case w: DataWriter[?] =>
       obj.value match {
         case seq: NodeSeq =>
           w.writer.asInstanceOf[CanWriteXML[A]].writes(obj.value, namespace, elementLabel, scope, typeAttribute)
@@ -695,7 +695,7 @@ trait ElemNameParser[A] extends AnyElemNameParser with XMLFormat[A] with CanWrit
   def reads(seq: scala.xml.NodeSeq, stack: List[ElemName]): Either[String, A] = seq match {
     case node: scala.xml.Node =>
       parse(parser(node, stack), node.child) match {
-        case x: Success[_] => Right(x.get)
+        case x: Success[?] => Right(x.get)
         case x: Failure => Left(parserErrorMsg(x.msg, x.next, ElemName(node) :: stack))
         case x: Error => Left(parserErrorMsg(x.msg, node))
       }

sbt-scalaxb/src/main/scala/sbtscalaxb/ScalaxbPlugin.scala

@@ -13,7 +13,7 @@ object ScalaxbPlugin extends sbt.AutoPlugin {
 
   object autoImport extends ScalaxbKeys
   import autoImport._
-  override lazy val globalSettings: Seq[Def.Setting[_]] = Seq(
+  override lazy val globalSettings: Seq[Def.Setting[?]] = Seq(
     scalaxbPackageName             := "generated",
     scalaxbPackageNames            := Map(),
     scalaxbClassPrefix             := None,
@@ -54,12 +54,12 @@ object ScalaxbPlugin extends sbt.AutoPlugin {
     scalaxbJaxbPackage             := JaxbPackage.Javax,
   )
 
-  override lazy val projectSettings: Seq[Def.Setting[_]] =
+  override lazy val projectSettings: Seq[Def.Setting[?]] =
     inConfig(Compile)(baseScalaxbSettings) ++
     Set(
       Compile / sourceGenerators += (Compile / scalaxb).taskValue
     )
-  lazy val baseScalaxbSettings: Seq[Def.Setting[_]] = Seq(
+  lazy val baseScalaxbSettings: Seq[Def.Setting[?]] = Seq(
     scalaxb := (scalaxb / scalaxbGenerate).value,
     scalaxb / sourceManaged := {
       sourceManaged.value / "sbt-scalaxb"