Create version specific folders for macros

- update scalafmt to use the scala 2.13 dialect unless it's in a scala-3 directory or is an sbt file
- create version specific directories for Macros and the objects that use them, with the traits/functions that need macros defined within the *UsingMacrosMixin traits. The only exception is needing to define AssertMacros outside of macro-lib since it needs access to the Assert class at compilation time and the macro class doesn't depend on the lib module.
- fix issue with abstract lazy val in NodeInfo, by removing it since it's not needed
- fix test path scala version for scala 3. Since Scala 3 uses the 2.13.16 library, scala.util.Properties.versionNumberString returns the library version, which in Scala 3 is 2.13.16. So we use universal/stage/lib to get the scala library version
- set type as needed
- verify removal of protected defs needed in scala 3
- fix formatting issue with frames map
- replace equals override with matches def since scla 3 doesn't allow comparing a string and DebugCommand using ==
- make scalaVersionForTargetPath lazy

DAFFODIL-2975

Author: mbeckerle

.scalafmt.conf

@@ -30,6 +30,14 @@ rewrite.rules = [
     Imports,
 ]
 rewrite.trailingCommas.style = never
-runner.dialect = scala212
+runner.dialect = scala213
 spaces.inImportCurlyBraces = true
 version = 3.8.3
+fileOverride {
+    "glob:**/src/main/scala-3/**" {
+        runner.dialect = scala3
+    }
+    "glob:**.sbt" {
+        runner.dialect = scala3
+    }
+}

daffodil-cli/src/test/scala/org/apache/daffodil/cli/cliTest/Util.scala

@@ -57,10 +57,35 @@ object Util {
     Paths.get(s"daffodil-cli/target/universal/stage/bin/daffodil$ext")
   }
 
-  val scalaVersionForTargetPath: String = scala.util.Properties.versionNumberString match {
-    case v if v.startsWith("2.12") => "scala-2.12"
-    case v if v.startsWith("2.13") => "scala-2.13"
-    case _ => throw new IllegalStateException("Unsupported version provided for tests")
+  lazy val scalaVersionForTargetPath: String = {
+    // scala.util.Properties.versionNumberString doesn't actually return scala 3.3.5 as expected
+    // when called in scala 3, as it returns the library version which is 2.13.16 for scala 2 and scala 3
+    // so we try to get the scala 3 version from the jar files and if it fails, we try for the scala 2 library
+    val scala3Regex = "org\\.scala-lang\\.scala3-library_3-([0-9.]+)\\.jar".r
+    val scala2Regex = "org\\.scala-lang\\.scala-library-([0-9.]+)\\.jar".r
+    val versionRegex = ".*-([0-9.]+)\\.jar".r
+
+    val jarFiles = Paths.get("daffodil-cli/target/universal/stage/lib").toFile.listFiles().toSeq
+
+    // Prioritize finding Scala 3 first, then fallback to Scala 2
+    val scalaLibraryFile = jarFiles
+      .find(f => scala3Regex.pattern.matcher(f.getName).matches())
+      .orElse(jarFiles.find(f => scala2Regex.pattern.matcher(f.getName).matches()))
+      .getOrElse(throw new IllegalStateException("No Scala library JAR found"))
+
+    // Extract Scala version using regex
+    val scalaVersion = versionRegex
+      .findFirstMatchIn(scalaLibraryFile.getName)
+      .map(_.group(1))
+      .getOrElse(throw new IllegalStateException("No Scala Version found"))
+
+    scalaVersion match {
+      case v if v.startsWith("2.12") => "scala-2.12"
+      case v if v.startsWith("2.13") => "scala-2.13"
+      case v if v.startsWith("3.") => "scala-" + v
+      case _ =>
+        throw new IllegalStateException(s"Unsupported version $scalaVersion provided for tests")
+    }
   }
 
   /**

daffodil-io/src/main/scala-2/org/apache/daffodil/io/IOUsingMacrosMixin.scala

@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.daffodil.io
+
+trait IOUsingMacrosMixin {
+
+  /**
+   * Convenience methods that temporarily set and (reliably) restore the bitLimit.
+   * The argument gives the limit length. Note this is a length, not a bit position.
+   *
+   * This is added to the current bit position to get the limiting bit position
+   * which is then set as the bitLimit when
+   * the body is evaluated. On return the bit limit is restored to its
+   * prior value.
+   * <p>
+   * The return value is false if the new bit limit is beyond the existing bit limit range.
+   * Otherwise the return value is true.
+   * <p>
+   * The prior value is restored even if an Error/Exception is thrown. (ie., via a try-finally)
+   * <p>
+   * These are intended for use implementing specified-length types (simple or complex).
+   * <p>
+   * Note that length limits in lengthUnits Characters are not implemented
+   * this way. See fillCharBuffer(cb) method.
+   */
+  final def withBitLengthLimit(lengthLimitInBits: Long)(body: => Unit): Boolean =
+    macro IOMacros.withBitLengthLimitMacroForInput
+}

daffodil-io/src/main/scala-3/org/apache/daffodil/io/IOUsingMacrosMixin.scala

@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.daffodil.io
+
+trait IOUsingMacrosMixin {
+  this: org.apache.daffodil.io.DataInputStream =>
+
+  /**
+   * Convenience methods that temporarily set and (reliably) restore the bitLimit.
+   * The argument gives the limit length. Note this is a length, not a bit position.
+   *
+   * This is added to the current bit position to get the limiting bit position
+   * which is then set as the bitLimit when
+   * the body is evaluated. On return the bit limit is restored to its
+   * prior value.
+   * <p>
+   * The return value is false if the new bit limit is beyond the existing bit limit range.
+   * Otherwise the return value is true.
+   * <p>
+   * The prior value is restored even if an Error/Exception is thrown. (ie., via a try-finally)
+   * <p>
+   * These are intended for use implementing specified-length types (simple or complex).
+   * <p>
+   * Note that length limits in lengthUnits Characters are not implemented
+   * this way. See fillCharBuffer(cb) method.
+   */
+  final inline def withBitLengthLimit(
+    lengthLimitInBits: Long
+  )(inline body: => Unit): Boolean = {
+    import org.apache.daffodil.lib.util.MaybeULong
+
+    val dStream = this
+    val newLengthLimit = lengthLimitInBits
+    val savedLengthLimit = dStream.bitLimit0b
+
+    if (!dStream.setBitLimit0b(MaybeULong(dStream.bitPos0b + newLengthLimit))) false
+    else {
+      try {
+        body
+      } finally {
+        dStream.resetBitLimit0b(savedLengthLimit)
+      }
+      true
+    }
+  }
+}

daffodil-io/src/main/scala/org/apache/daffodil/io/DataInputStream.scala

@@ -14,7 +14,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.apache.daffodil.io
 
 import java.math.{ BigInteger => JBigInt }
@@ -169,7 +168,7 @@ object DataInputStream {
 
 }
 
-trait DataInputStream extends DataStreamCommon {
+trait DataInputStream extends DataStreamCommon with IOUsingMacrosMixin {
   import DataInputStream._
 
   /**
@@ -529,28 +528,6 @@ trait DataInputStream extends DataStreamCommon {
   def markPos: MarkPos
   def resetPos(m: MarkPos): Unit
 
-  /**
-   * Convenience methods that temporarily set and (reliably) restore the bitLimit.
-   * The argument gives the limit length. Note this is a length, not a bit position.
-   *
-   * This is added to the current bit position to get the limiting bit position
-   * which is then set as the bitLimit when
-   * the body is evaluated. On return the bit limit is restored to its
-   * prior value.
-   * <p>
-   * The return value is false if the new bit limit is beyond the existing bit limit range.
-   * Otherwise the return value is true.
-   * <p>
-   * The prior value is restored even if an Error/Exception is thrown. (ie., via a try-finally)
-   * <p>
-   * These are intended for use implementing specified-length types (simple or complex).
-   * <p>
-   * Note that length limits in lengthUnits Characters are not implemented
-   * this way. See fillCharBuffer(cb) method.
-   */
-  final def withBitLengthLimit(lengthLimitInBits: Long)(body: => Unit): Boolean =
-    macro IOMacros.withBitLengthLimitMacroForInput
-
   /**
    * Closes any underlying I/O streams/channels that are part of the implementation
    * of this and frees related resources.

daffodil-io/src/main/scala/org/apache/daffodil/io/DataOutputStreamImplMixin.scala

@@ -277,7 +277,7 @@ trait DataOutputStreamImplMixin
    * Returns false if the set was unsuccessful, meaning one is setting a limit that
    * extends past a pre-existing limit.
    */
-  protected def setMaybeRelBitLimit0b(
+  def setMaybeRelBitLimit0b(
     newMaybeRelBitLimit0b: MaybeULong,
     reset: Boolean = false
   ): Boolean = {
@@ -330,7 +330,7 @@ trait DataOutputStreamImplMixin
    * Always between 0 and 7 inclusive.
    */
   private var fragmentLastByteLimit_ : Int = 0
-  def fragmentLastByteLimit = fragmentLastByteLimit_
+  def fragmentLastByteLimit: Int = fragmentLastByteLimit_
 
   def setFragmentLastByte(newFragmentByte: Int, nBitsInUse: Int): Unit = {
     Assert.usage(nBitsInUse >= 0 && nBitsInUse <= 7)
@@ -375,7 +375,7 @@ trait DataOutputStreamImplMixin
 
   protected def getJavaOutputStream(): java.io.OutputStream
 
-  final protected def cst = this
+  final def cst: DataOutputStreamImplMixin = this
 
   protected def assignFrom(other: DataOutputStreamImplMixin): Unit = {
     Assert.usage(isWritable)
@@ -711,7 +711,7 @@ trait DataOutputStreamImplMixin
   ): Long = {
     Assert.usage(isWritable)
     if (isEndOnByteBoundary) {
-      val nBytes =
+      val nBytes: Long =
         if (exceedsBitLimit(lengthInBytes)) {
           val n = (maybeRelBitLimit0b.getULong - relBitPos0b) / 8
           Assert.invariant(n >= 0)
@@ -849,7 +849,7 @@ trait DataOutputStreamImplMixin
 
   private def putByteBuffer(bb: java.nio.ByteBuffer, finfo: FormatInfo): Long = {
     Assert.usage(isWritable)
-    val nTransferred =
+    val nTransferred: Long =
       if (bb.hasArray) {
         putBytes(bb.array, bb.arrayOffset + bb.position(), bb.remaining(), finfo)
       } else {

daffodil-io/src/main/scala/org/apache/daffodil/io/Dump.scala

@@ -617,14 +617,14 @@ class DataDumper {
           Assert.invariant(cb.hasArray)
           val allChars = cb.array
 
-          val uCodePoint =
+          val uCodePoint: Int =
             if (allChars.length > 1) {
               if (UCharacter.isSurrogatePair(allChars(0), allChars(1))) {
                 UCharacter.getCodePoint(allChars(0), allChars(1))
               } else {
                 INVALID_CODEPOINT
               }
-            } else allChars(0)
+            } else allChars(0).toInt
 
           val (r: String, n: Int) =
             if (allChars.length > 1) {

daffodil-io/src/main/scala/org/apache/daffodil/io/processors/charset/BitsCharsetDefinition.scala

@@ -30,5 +30,5 @@ abstract class BitsCharsetDefinition(
 ) extends SimpleNamedLoadableService {
   final def name(): String = alias.getOrElse(charsetArg.name).toUpperCase()
 
-  final def charset(): BitsCharset = charsetArg
+  final def charset: BitsCharset = charsetArg
 }

daffodil-io/src/main/scala/org/apache/daffodil/io/processors/charset/CharsetUtils.scala

@@ -38,7 +38,7 @@ object CharsetUtils {
     if (cs == null)
       null
     else
-      cs.charset()
+      cs.charset
   }
 
   def supportedEncodingsString = BitsCharsetDefinitionRegistry.supportedEncodingsString

daffodil-japi/src/test/java/org/apache/daffodil/example/TestCustomDebuggerAPI.java

@@ -32,7 +32,6 @@
 import java.io.IOException;
 import java.net.URI;
 
-import static java.util.Objects.nonNull;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 

daffodil-lib/src/main/scala-2/org/apache/daffodil/lib/exceptions/AssertsUsingMacrosMixin.scala

@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.daffodil.lib.exceptions
+
+trait AssertsUsingMacrosMixin {
+
+  /**
+   * Verbose name helps you get the sense of the predicate right.
+   */
+  def usageErrorUnless(testAbortsIfFalse: Boolean, message: String): Unit =
+    macro AssertMacros.usageMacro2
+
+  def usageErrorUnless(testAbortsIfFalse: Boolean, cause: Throwable): Unit =
+    macro AssertMacros.usageMacro2Cause
+
+  def usageErrorUnless(testAbortsIfFalse: Boolean): Unit = macro AssertMacros.usageMacro1
+
+  /**
+   * Brief form
+   */
+  def usage(testAbortsIfFalse: Boolean, message: String): Unit = macro AssertMacros.usageMacro2
+
+  def usageWithCause(testAbortsIfFalse: Boolean, cause: Throwable): Unit =
+    macro AssertMacros.usageMacro2Cause
+
+  def usage(testAbortsIfFalse: Boolean): Unit =
+    macro AssertMacros.usageMacro1
+
+  /**
+   * test for something that the program is supposed to be ensuring.
+   *
+   * This is for more complex invariants than the simple 'impossible' case.
+   */
+  def invariant(testAbortsIfFalse: Boolean): Unit = macro AssertMacros.invariantMacro1
+
+  /**
+   * test for something that the program is supposed to be ensuring, with a custom error message.
+   *
+   * This is for more complex invariants than the simple 'impossible' case.
+   *
+   * The msg parameter is only evaluated if the test fails
+   */
+  def invariant(testAbortsIfFalse: Boolean, msg: String): Unit =
+    macro AssertMacros.invariantMacro2
+
+  /**
+   * Conditional behavior for NYIs
+   */
+  def notYetImplemented(testThatWillThrowIfTrue: Boolean): Unit =
+    macro AssertMacros.notYetImplementedMacro1
+
+  def notYetImplemented(testThatWillThrowIfTrue: Boolean, msg: String): Unit =
+    macro AssertMacros.notYetImplementedMacro2
+}