• Home
• org.scala-lang
• scala3-compiler_3
• 3.6.3-RC1-bin-20241119-7155a8b-NIGHTLY
• source code
• Constant.scala

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

dotty.tools.dotc.semanticdb.generated.Constant.scala Maven / Gradle / Ivy

// Generated by https://github.com/tanishiking/semanticdb-for-scala3
// Generated by the Scala Plugin for the Protocol Buffer Compiler.
// Do not edit!
//
// Protofile syntax: PROTO3

package dotty.tools.dotc.semanticdb
import dotty.tools.dotc.semanticdb.internal.*
import scala.annotation.internal.sharable

sealed trait Constant  extends SemanticdbGeneratedSealedOneof  derives CanEqual {
  type MessageType = dotty.tools.dotc.semanticdb.ConstantMessage
  final def isEmpty = this.isInstanceOf[dotty.tools.dotc.semanticdb.Constant.Empty.type]
  final def isDefined = !isEmpty
  final def asMessage: dotty.tools.dotc.semanticdb.ConstantMessage = dotty.tools.dotc.semanticdb.Constant.ConstantTypeMapper.toBase(this)
  final def asNonEmpty: Option[dotty.tools.dotc.semanticdb.Constant.NonEmpty] = if (isEmpty) None else Some(this.asInstanceOf[dotty.tools.dotc.semanticdb.Constant.NonEmpty])
}

object Constant {
  case object Empty extends dotty.tools.dotc.semanticdb.Constant

  sealed trait NonEmpty extends dotty.tools.dotc.semanticdb.Constant
  def defaultInstance: dotty.tools.dotc.semanticdb.Constant = Empty

  implicit val ConstantTypeMapper: SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant] = new SemanticdbTypeMapper[dotty.tools.dotc.semanticdb.ConstantMessage, dotty.tools.dotc.semanticdb.Constant] {
    override def toCustom(__base: dotty.tools.dotc.semanticdb.ConstantMessage): dotty.tools.dotc.semanticdb.Constant = __base.sealedValue match {
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant => __v.value
      case __v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant => __v.value
      case dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty => Empty
    }
    override def toBase(__custom: dotty.tools.dotc.semanticdb.Constant): dotty.tools.dotc.semanticdb.ConstantMessage = dotty.tools.dotc.semanticdb.ConstantMessage(__custom match {
      case __v: dotty.tools.dotc.semanticdb.UnitConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.BooleanConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.ByteConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.ShortConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.CharConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.IntConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.LongConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.FloatConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.DoubleConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.StringConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant(__v)
      case __v: dotty.tools.dotc.semanticdb.NullConstant => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant(__v)
      case Empty => dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
    })
  }
}
@SerialVersionUID(0L)
final case class ConstantMessage(
    sealedValue: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
    )  extends SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0
      if (sealedValue.unitConstant.isDefined) {
        val __value = sealedValue.unitConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.booleanConstant.isDefined) {
        val __value = sealedValue.booleanConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.byteConstant.isDefined) {
        val __value = sealedValue.byteConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.shortConstant.isDefined) {
        val __value = sealedValue.shortConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.charConstant.isDefined) {
        val __value = sealedValue.charConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.intConstant.isDefined) {
        val __value = sealedValue.intConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.longConstant.isDefined) {
        val __value = sealedValue.longConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.floatConstant.isDefined) {
        val __value = sealedValue.floatConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.doubleConstant.isDefined) {
        val __value = sealedValue.doubleConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.stringConstant.isDefined) {
        val __value = sealedValue.stringConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      if (sealedValue.nullConstant.isDefined) {
        val __value = sealedValue.nullConstant.get
        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      sealedValue.unitConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(1, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.booleanConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(2, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.byteConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(3, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.shortConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(4, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.charConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(5, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.intConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(6, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.longConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(7, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.floatConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(8, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.doubleConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(9, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.stringConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(10, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
      sealedValue.nullConstant.foreach { __v =>
        val __m = __v
        _output__.writeTag(11, 2)
        _output__.writeUInt32NoTag(__m.serializedSize)
        __m.writeTo(_output__)
      };
    }
    def getUnitConstant: dotty.tools.dotc.semanticdb.UnitConstant = sealedValue.unitConstant.getOrElse(dotty.tools.dotc.semanticdb.UnitConstant.defaultInstance)
    def withUnitConstant(__v: dotty.tools.dotc.semanticdb.UnitConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant(__v))
    def getBooleanConstant: dotty.tools.dotc.semanticdb.BooleanConstant = sealedValue.booleanConstant.getOrElse(dotty.tools.dotc.semanticdb.BooleanConstant.defaultInstance)
    def withBooleanConstant(__v: dotty.tools.dotc.semanticdb.BooleanConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant(__v))
    def getByteConstant: dotty.tools.dotc.semanticdb.ByteConstant = sealedValue.byteConstant.getOrElse(dotty.tools.dotc.semanticdb.ByteConstant.defaultInstance)
    def withByteConstant(__v: dotty.tools.dotc.semanticdb.ByteConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant(__v))
    def getShortConstant: dotty.tools.dotc.semanticdb.ShortConstant = sealedValue.shortConstant.getOrElse(dotty.tools.dotc.semanticdb.ShortConstant.defaultInstance)
    def withShortConstant(__v: dotty.tools.dotc.semanticdb.ShortConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant(__v))
    def getCharConstant: dotty.tools.dotc.semanticdb.CharConstant = sealedValue.charConstant.getOrElse(dotty.tools.dotc.semanticdb.CharConstant.defaultInstance)
    def withCharConstant(__v: dotty.tools.dotc.semanticdb.CharConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant(__v))
    def getIntConstant: dotty.tools.dotc.semanticdb.IntConstant = sealedValue.intConstant.getOrElse(dotty.tools.dotc.semanticdb.IntConstant.defaultInstance)
    def withIntConstant(__v: dotty.tools.dotc.semanticdb.IntConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant(__v))
    def getLongConstant: dotty.tools.dotc.semanticdb.LongConstant = sealedValue.longConstant.getOrElse(dotty.tools.dotc.semanticdb.LongConstant.defaultInstance)
    def withLongConstant(__v: dotty.tools.dotc.semanticdb.LongConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant(__v))
    def getFloatConstant: dotty.tools.dotc.semanticdb.FloatConstant = sealedValue.floatConstant.getOrElse(dotty.tools.dotc.semanticdb.FloatConstant.defaultInstance)
    def withFloatConstant(__v: dotty.tools.dotc.semanticdb.FloatConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant(__v))
    def getDoubleConstant: dotty.tools.dotc.semanticdb.DoubleConstant = sealedValue.doubleConstant.getOrElse(dotty.tools.dotc.semanticdb.DoubleConstant.defaultInstance)
    def withDoubleConstant(__v: dotty.tools.dotc.semanticdb.DoubleConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant(__v))
    def getStringConstant: dotty.tools.dotc.semanticdb.StringConstant = sealedValue.stringConstant.getOrElse(dotty.tools.dotc.semanticdb.StringConstant.defaultInstance)
    def withStringConstant(__v: dotty.tools.dotc.semanticdb.StringConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant(__v))
    def getNullConstant: dotty.tools.dotc.semanticdb.NullConstant = sealedValue.nullConstant.getOrElse(dotty.tools.dotc.semanticdb.NullConstant.defaultInstance)
    def withNullConstant(__v: dotty.tools.dotc.semanticdb.NullConstant): ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant(__v))
    def clearSealedValue: ConstantMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty)
    def withSealedValue(__v: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue): ConstantMessage = copy(sealedValue = __v)




    def toConstant: dotty.tools.dotc.semanticdb.Constant = dotty.tools.dotc.semanticdb.Constant.ConstantTypeMapper.toCustom(this)
    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.Constant])
}

object ConstantMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ConstantMessage] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ConstantMessage] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ConstantMessage = {
    var __sealedValue: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 10 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.UnitConstant(__sealedValue.unitConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.UnitConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 18 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.BooleanConstant(__sealedValue.booleanConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.BooleanConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 26 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ByteConstant(__sealedValue.byteConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ByteConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 34 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.ShortConstant(__sealedValue.shortConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.ShortConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 42 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.CharConstant(__sealedValue.charConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.CharConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 50 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.IntConstant(__sealedValue.intConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.IntConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 58 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.LongConstant(__sealedValue.longConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.LongConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 66 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.FloatConstant(__sealedValue.floatConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.FloatConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 74 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.DoubleConstant(__sealedValue.doubleConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.DoubleConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 82 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.StringConstant(__sealedValue.stringConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.StringConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case 90 =>
          __sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.NullConstant(__sealedValue.nullConstant.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.NullConstant](_input__))(LiteParser.readMessage(_input__, _)))
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.ConstantMessage(
        sealedValue = __sealedValue
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ConstantMessage(
    sealedValue = dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue.Empty
  )
  sealed trait SealedValue  extends SemanticdbGeneratedOneof  derives CanEqual {
    def isEmpty: _root_.scala.Boolean = false
    def isDefined: _root_.scala.Boolean = true
    def isUnitConstant: _root_.scala.Boolean = false
    def isBooleanConstant: _root_.scala.Boolean = false
    def isByteConstant: _root_.scala.Boolean = false
    def isShortConstant: _root_.scala.Boolean = false
    def isCharConstant: _root_.scala.Boolean = false
    def isIntConstant: _root_.scala.Boolean = false
    def isLongConstant: _root_.scala.Boolean = false
    def isFloatConstant: _root_.scala.Boolean = false
    def isDoubleConstant: _root_.scala.Boolean = false
    def isStringConstant: _root_.scala.Boolean = false
    def isNullConstant: _root_.scala.Boolean = false
    def unitConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.UnitConstant] = _root_.scala.None
    def booleanConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.BooleanConstant] = _root_.scala.None
    def byteConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ByteConstant] = _root_.scala.None
    def shortConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ShortConstant] = _root_.scala.None
    def charConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.CharConstant] = _root_.scala.None
    def intConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.IntConstant] = _root_.scala.None
    def longConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.LongConstant] = _root_.scala.None
    def floatConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.FloatConstant] = _root_.scala.None
    def doubleConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.DoubleConstant] = _root_.scala.None
    def stringConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.StringConstant] = _root_.scala.None
    def nullConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.NullConstant] = _root_.scala.None
  }
  object SealedValue {
    @SerialVersionUID(0L)
    case object Empty extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue {
      type ValueType = _root_.scala.Nothing
      override def isEmpty: _root_.scala.Boolean = true
      override def isDefined: _root_.scala.Boolean = false
      override def number: _root_.scala.Int = 0
      override def value: _root_.scala.Nothing = throw new java.util.NoSuchElementException("Empty.value")
    }

    @SerialVersionUID(0L)
    final case class UnitConstant(value: dotty.tools.dotc.semanticdb.UnitConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.UnitConstant
      override def isUnitConstant: _root_.scala.Boolean = true
      override def unitConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.UnitConstant] = Some(value)
      override def number: _root_.scala.Int = 1
    }
    @SerialVersionUID(0L)
    final case class BooleanConstant(value: dotty.tools.dotc.semanticdb.BooleanConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.BooleanConstant
      override def isBooleanConstant: _root_.scala.Boolean = true
      override def booleanConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.BooleanConstant] = Some(value)
      override def number: _root_.scala.Int = 2
    }
    @SerialVersionUID(0L)
    final case class ByteConstant(value: dotty.tools.dotc.semanticdb.ByteConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.ByteConstant
      override def isByteConstant: _root_.scala.Boolean = true
      override def byteConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ByteConstant] = Some(value)
      override def number: _root_.scala.Int = 3
    }
    @SerialVersionUID(0L)
    final case class ShortConstant(value: dotty.tools.dotc.semanticdb.ShortConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.ShortConstant
      override def isShortConstant: _root_.scala.Boolean = true
      override def shortConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.ShortConstant] = Some(value)
      override def number: _root_.scala.Int = 4
    }
    @SerialVersionUID(0L)
    final case class CharConstant(value: dotty.tools.dotc.semanticdb.CharConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.CharConstant
      override def isCharConstant: _root_.scala.Boolean = true
      override def charConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.CharConstant] = Some(value)
      override def number: _root_.scala.Int = 5
    }
    @SerialVersionUID(0L)
    final case class IntConstant(value: dotty.tools.dotc.semanticdb.IntConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.IntConstant
      override def isIntConstant: _root_.scala.Boolean = true
      override def intConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.IntConstant] = Some(value)
      override def number: _root_.scala.Int = 6
    }
    @SerialVersionUID(0L)
    final case class LongConstant(value: dotty.tools.dotc.semanticdb.LongConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.LongConstant
      override def isLongConstant: _root_.scala.Boolean = true
      override def longConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.LongConstant] = Some(value)
      override def number: _root_.scala.Int = 7
    }
    @SerialVersionUID(0L)
    final case class FloatConstant(value: dotty.tools.dotc.semanticdb.FloatConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.FloatConstant
      override def isFloatConstant: _root_.scala.Boolean = true
      override def floatConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.FloatConstant] = Some(value)
      override def number: _root_.scala.Int = 8
    }
    @SerialVersionUID(0L)
    final case class DoubleConstant(value: dotty.tools.dotc.semanticdb.DoubleConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.DoubleConstant
      override def isDoubleConstant: _root_.scala.Boolean = true
      override def doubleConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.DoubleConstant] = Some(value)
      override def number: _root_.scala.Int = 9
    }
    @SerialVersionUID(0L)
    final case class StringConstant(value: dotty.tools.dotc.semanticdb.StringConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.StringConstant
      override def isStringConstant: _root_.scala.Boolean = true
      override def stringConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.StringConstant] = Some(value)
      override def number: _root_.scala.Int = 10
    }
    @SerialVersionUID(0L)
    final case class NullConstant(value: dotty.tools.dotc.semanticdb.NullConstant) extends dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue  derives CanEqual {
      type ValueType = dotty.tools.dotc.semanticdb.NullConstant
      override def isNullConstant: _root_.scala.Boolean = true
      override def nullConstant: _root_.scala.Option[dotty.tools.dotc.semanticdb.NullConstant] = Some(value)
      override def number: _root_.scala.Int = 11
    }
  }
  final val UNIT_CONSTANT_FIELD_NUMBER = 1
  final val BOOLEAN_CONSTANT_FIELD_NUMBER = 2
  final val BYTE_CONSTANT_FIELD_NUMBER = 3
  final val SHORT_CONSTANT_FIELD_NUMBER = 4
  final val CHAR_CONSTANT_FIELD_NUMBER = 5
  final val INT_CONSTANT_FIELD_NUMBER = 6
  final val LONG_CONSTANT_FIELD_NUMBER = 7
  final val FLOAT_CONSTANT_FIELD_NUMBER = 8
  final val DOUBLE_CONSTANT_FIELD_NUMBER = 9
  final val STRING_CONSTANT_FIELD_NUMBER = 10
  final val NULL_CONSTANT_FIELD_NUMBER = 11
  def of(
    sealedValue: dotty.tools.dotc.semanticdb.ConstantMessage.SealedValue
  ): _root_.dotty.tools.dotc.semanticdb.ConstantMessage = _root_.dotty.tools.dotc.semanticdb.ConstantMessage(
    sealedValue
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.Constant])
}

@SerialVersionUID(0L)
final case class UnitConstant(
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    final override def serializedSize: _root_.scala.Int = 0
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
    }




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.UnitConstant])
}

object UnitConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnitConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnitConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.UnitConstant = {
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.UnitConstant(
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.UnitConstant(
  )
  def of(
  ): _root_.dotty.tools.dotc.semanticdb.UnitConstant = _root_.dotty.tools.dotc.semanticdb.UnitConstant(
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.UnitConstant])
}

@SerialVersionUID(0L)
final case class BooleanConstant(
    value: _root_.scala.Boolean = false
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != false) {
          __size += SemanticdbOutputStream.computeBoolSize(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != false) {
          _output__.writeBool(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Boolean): BooleanConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.BooleanConstant])
}

object BooleanConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.BooleanConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.BooleanConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.BooleanConstant = {
    var __value: _root_.scala.Boolean = false
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 8 =>
          __value = _input__.readBool()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.BooleanConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.BooleanConstant(
    value = false
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Boolean
  ): _root_.dotty.tools.dotc.semanticdb.BooleanConstant = _root_.dotty.tools.dotc.semanticdb.BooleanConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.BooleanConstant])
}

@SerialVersionUID(0L)
final case class ByteConstant(
    value: _root_.scala.Int = 0
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != 0) {
          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != 0) {
          _output__.writeInt32(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Int): ByteConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ByteConstant])
}

object ByteConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByteConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByteConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ByteConstant = {
    var __value: _root_.scala.Int = 0
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 8 =>
          __value = _input__.readInt32()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.ByteConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ByteConstant(
    value = 0
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Int
  ): _root_.dotty.tools.dotc.semanticdb.ByteConstant = _root_.dotty.tools.dotc.semanticdb.ByteConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ByteConstant])
}

@SerialVersionUID(0L)
final case class ShortConstant(
    value: _root_.scala.Int = 0
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != 0) {
          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != 0) {
          _output__.writeInt32(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Int): ShortConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.ShortConstant])
}

object ShortConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ShortConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ShortConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.ShortConstant = {
    var __value: _root_.scala.Int = 0
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 8 =>
          __value = _input__.readInt32()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.ShortConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.ShortConstant(
    value = 0
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Int
  ): _root_.dotty.tools.dotc.semanticdb.ShortConstant = _root_.dotty.tools.dotc.semanticdb.ShortConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.ShortConstant])
}

@SerialVersionUID(0L)
final case class CharConstant(
    value: _root_.scala.Int = 0
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != 0) {
          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != 0) {
          _output__.writeInt32(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Int): CharConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.CharConstant])
}

object CharConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.CharConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.CharConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.CharConstant = {
    var __value: _root_.scala.Int = 0
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 8 =>
          __value = _input__.readInt32()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.CharConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.CharConstant(
    value = 0
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Int
  ): _root_.dotty.tools.dotc.semanticdb.CharConstant = _root_.dotty.tools.dotc.semanticdb.CharConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.CharConstant])
}

@SerialVersionUID(0L)
final case class IntConstant(
    value: _root_.scala.Int = 0
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != 0) {
          __size += SemanticdbOutputStream.computeInt32Size(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != 0) {
          _output__.writeInt32(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Int): IntConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.IntConstant])
}

object IntConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.IntConstant = {
    var __value: _root_.scala.Int = 0
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 8 =>
          __value = _input__.readInt32()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.IntConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.IntConstant(
    value = 0
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Int
  ): _root_.dotty.tools.dotc.semanticdb.IntConstant = _root_.dotty.tools.dotc.semanticdb.IntConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.IntConstant])
}

@SerialVersionUID(0L)
final case class LongConstant(
    value: _root_.scala.Long = 0L
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != 0L) {
          __size += SemanticdbOutputStream.computeInt64Size(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != 0L) {
          _output__.writeInt64(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Long): LongConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.LongConstant])
}

object LongConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LongConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LongConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.LongConstant = {
    var __value: _root_.scala.Long = 0L
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 8 =>
          __value = _input__.readInt64()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.LongConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.LongConstant(
    value = 0L
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Long
  ): _root_.dotty.tools.dotc.semanticdb.LongConstant = _root_.dotty.tools.dotc.semanticdb.LongConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LongConstant])
}

@SerialVersionUID(0L)
final case class FloatConstant(
    value: _root_.scala.Float = 0.0f
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != 0.0f) {
          __size += SemanticdbOutputStream.computeFloatSize(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != 0.0f) {
          _output__.writeFloat(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Float): FloatConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.FloatConstant])
}

object FloatConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FloatConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FloatConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.FloatConstant = {
    var __value: _root_.scala.Float = 0.0f
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 13 =>
          __value = _input__.readFloat()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.FloatConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.FloatConstant(
    value = 0.0f
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Float
  ): _root_.dotty.tools.dotc.semanticdb.FloatConstant = _root_.dotty.tools.dotc.semanticdb.FloatConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.FloatConstant])
}

@SerialVersionUID(0L)
final case class DoubleConstant(
    value: _root_.scala.Double = 0.0
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (__value != 0.0) {
          __size += SemanticdbOutputStream.computeDoubleSize(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (__v != 0.0) {
          _output__.writeDouble(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Double): DoubleConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.DoubleConstant])
}

object DoubleConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.DoubleConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.DoubleConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.DoubleConstant = {
    var __value: _root_.scala.Double = 0.0
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 9 =>
          __value = _input__.readDouble()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.DoubleConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.DoubleConstant(
    value = 0.0
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Double
  ): _root_.dotty.tools.dotc.semanticdb.DoubleConstant = _root_.dotty.tools.dotc.semanticdb.DoubleConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.DoubleConstant])
}

@SerialVersionUID(0L)
final case class StringConstant(
    value: _root_.scala.Predef.String = ""
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    @transient @sharable
    private var __serializedSizeMemoized: _root_.scala.Int = 0
    private def __computeSerializedSize(): _root_.scala.Int = {
      var __size = 0

      {
        val __value = value
        if (!__value.isEmpty) {
          __size += SemanticdbOutputStream.computeStringSize(1, __value)
        }
      };
      __size
    }
    override def serializedSize: _root_.scala.Int = {
      var __size = __serializedSizeMemoized
      if (__size == 0) {
        __size = __computeSerializedSize() + 1
        __serializedSizeMemoized = __size
      }
      __size - 1

    }
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
      {
        val __v = value
        if (!__v.isEmpty) {
          _output__.writeString(1, __v)
        }
      };
    }
    def withValue(__v: _root_.scala.Predef.String): StringConstant = copy(value = __v)




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.StringConstant])
}

object StringConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StringConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StringConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.StringConstant = {
    var __value: _root_.scala.Predef.String = ""
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case 10 =>
          __value = _input__.readStringRequireUtf8()
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.StringConstant(
        value = __value
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.StringConstant(
    value = ""
  )
  final val VALUE_FIELD_NUMBER = 1
  def of(
    value: _root_.scala.Predef.String
  ): _root_.dotty.tools.dotc.semanticdb.StringConstant = _root_.dotty.tools.dotc.semanticdb.StringConstant(
    value
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.StringConstant])
}

@SerialVersionUID(0L)
final case class NullConstant(
    )  extends dotty.tools.dotc.semanticdb.Constant.NonEmpty with SemanticdbGeneratedMessage  derives CanEqual {
    final override def serializedSize: _root_.scala.Int = 0
    def writeTo(`_output__`: SemanticdbOutputStream): _root_.scala.Unit = {
    }




    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.NullConstant])
}

object NullConstant  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.NullConstant] {
  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.NullConstant] = this
  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.NullConstant = {
    var _done__ = false
    while (!_done__) {
      val _tag__ = _input__.readTag()
      _tag__ match {
        case 0 => _done__ = true
        case tag => _input__.skipField(tag)
      }
    }
    dotty.tools.dotc.semanticdb.NullConstant(
    )
  }






  lazy val defaultInstance = dotty.tools.dotc.semanticdb.NullConstant(
  )
  def of(
  ): _root_.dotty.tools.dotc.semanticdb.NullConstant = _root_.dotty.tools.dotc.semanticdb.NullConstant(
  )
  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.NullConstant])
}