Value Members

1.  val LedgerApplicationId: daml.lf.data.Ref.ApplicationId.type
2.  val LedgerConfiguration: Configuration.type
3.  val LedgerParticipantId: ParticipantId.type
4.  val LedgerSubmissionId: SubmissionId.type
5.  val LedgerTransactionId: TransactionId.type
6.  val LfChoiceName: ChoiceName.type
7.  val LfCommand: ReplayCommand.type
8.  val LfCreateCommand: Create.type
9.  val LfExerciseByKeyCommand: ExerciseByKey.type
10.  val LfExerciseCommand: Exercise.type
11.  val LfFetchByKeyCommand: FetchByKey.type
12.  val LfFetchCommand: Fetch.type
13.  val LfIdentifier: Identifier.type
14.  val LfInterfaceId: TypeConName.type
15.  val LfLedgerString: LedgerString.type
16.  val LfLookupByKeyCommand: LookupByKey.type
17.  val LfPackageId: PackageId.type
18.  val LfPartyId: Party.type
19.  val LfTimestamp: Timestamp.type
20.  val LfValue: Value.type
21.  val LfVersioned: Versioned.type
22.  val LfWorkflowId: daml.lf.data.Ref.WorkflowId.type
23.  val SequencerCounter: CounterCompanion[SequencerCounterDiscriminator]
24.  def checked[A](x: => A): A

    Wrap a method call with this method to document that the caller is sure that the callee's preconditions are met.

25.  implicit val lfPartyOrdering: Ordering[LfPartyId]
26.  object ApplicationId extends Serializable
27.  object CantonCommunityApp extends CantonAppDriver[CommunityEnvironment]
28.  object CantonEnterpriseApp extends CantonAppDriver[EnterpriseEnvironment]
29.  object CantonResearchApp extends CantonAppDriver[ResearchEnvironment]
30.  object CommandId extends Serializable
31.  object ConsoleScriptRunner extends NoTracing
32.  object DiscardedFuture extends WartTraverser

    Flags statements that return a scala.concurrent.Future.

    Flags statements that return a scala.concurrent.Future. Typically, we should not discard scala.concurrent.Future because exceptions inside the future may not get logged. Use FutureUtil.doNotAwait to log exceptions and discard the future where necessary.

    Also detects discarded cats.data.EitherT[scala.concurrent.Future, ..., ...] and cats.data.OptionT[scala.concurrent.Future, ...] and arbitrary nestings of those. Custom type constructors can be registered to take the same role as scala.concurrent.Future by annotating the type definition with DoNotDiscardLikeFuture.

    Also flags usages of scala.collection.IterableOnceOps.foreach and scala.collection.IterableOnceOps.tapEach where the function returns a future-like type.

    This wart is a special case of the warts NonUnitStatements and NonUnitForEach and scalac's -Wnonunit-statement flag, in that it warns only if the return type is future-like. Additionally, this wart uses a different set of exceptions when no warning is issued. We keep this specialized wart for two reasons: 1. It is not practically feasible to use -Wnonunit-statement and NonUnitForEach in scalatest because it would flag many of the assertions of the form x should be >= y in statement positions. Yet, it is important to check for discarded futures in tests because a discarded future may hide an exception. 2. In some production code, it is convenient to suppress the warnings coming from -Wnonunit-statement and NonUnitForEach, just due to how the code is written. In such places, we still want to benefit from the explicit checks against discarded futures.

    This wart does not look at futures that are discarded at the end of a unit-type expression. These cases are caught by -Ywarn-value-discard. We do not implement a specialized version for future-like values because we do not expect to suppress the warnings coming from -Ywarn-value-discard.

33.  object DomainAlias extends LengthLimitedStringWrapperCompanion[String255, DomainAlias] with Serializable
34.  object FutureLikeTester
35.  object FutureTraverse extends WartTraverser

    Cats' traverse and sequence methods do not specify the evaluation behaviour and this behaviour has changed between minor versions (e.g., 2.6 and 2.7).

    Cats' traverse and sequence methods do not specify the evaluation behaviour and this behaviour has changed between minor versions (e.g., 2.6 and 2.7). When we traverse over containers, we should therefore be explicit whether the traversal is parallel or sequential. This wart flags all usages of Cats' syntax extensions for future-like applicatives, except when used with the singleton containers scala.Option and scala.Either.

    Limitations: - It does not flag traverse calls whose applicative instance is more general and can be instantiated with a future-like instance.

36.  object NonUnitForEach extends WartTraverser

    This wart warns when methods scala.collection.IterableOnceOps.foreach and scala.collection.IterableOnceOps.tapEach are used with non-unit valued functions.

    This wart warns when methods scala.collection.IterableOnceOps.foreach and scala.collection.IterableOnceOps.tapEach are used with non-unit valued functions. This is needed because these methods' signature accepts any-valued functions. So -Ywarn-value-discard does not warn about such discarded values.

    scala.collection.IterableOnceOps.foreach is also used in for loops without yield and therefore also covers cases such as for { x <- 1 to 10 } { x + 5 }.

    Builder operations such as b += ... are identified by their return type this.type and ignored when checking for non-unit return values. This allows common usages such as for { x <- 1 to 10 } { b += x } and for { x <- 1 to 10 } { if (x % 2 == 0) b += x }. This does not work for all usages though; you can force a Unit type by specifying the type argument of scala.collection.IterableOnceOps.foreach and scala.collection.IterableOnceOps.tapEach as in (1 to 10).foreach[Unit] { ... }, or by ascribing Unit as in (1 to 10).foreach { x => f(x): Unit }, or by explicitly discarding the result: (1 to 10).foreach { x => f(x).discard }.

37.  object ProtoDeserializationError extends ProtoDeserializationErrorGroup with Serializable
38.  object RequestCounter extends CounterCompanion[RequestCounterDiscriminator]
39.  object RequireBlocking extends WartTraverser

    All blocking method calls should be wrapped in scala.concurrent.blocking so that the execution context knows that it may have to spawn a new process.

    All blocking method calls should be wrapped in scala.concurrent.blocking so that the execution context knows that it may have to spawn a new process.

    This wart checks that all @{code synchronized} calls are surrounded immediately by a scala.concurrent.blocking call. It also complains about calls to java.lang.Thread.sleep as Threading.sleep should be used instead.

    The logic can currently be fooled by renaming synchronized and sleep.

40.  object SlickString extends WartTraverser

    The DB may truncate strings of unbounded length.

    The DB may truncate strings of unbounded length. Therefore, this wart flags the following:

    • Calls to slick.jdbc.PositionedParameters.setString
    • Calls to slick.jdbc.PositionedParameters.setStringOption
    • References to slick.jdbc.SetParameter.SetString
    • References to slick.jdbc.SetParameter.SetStringOption

    This includes references generated by the string interpolators sql and sqlu

41.  object WorkflowId extends Serializable