): List<LighterASTNode> {
    val ref = Ref<Array<LighterASTNode?>>()
    getChildren(node, ref)
    return ref.get()
        .filterNotNull()
        .filter { it.isUseful }
} // TODO: any usages that need to be checked for parsing errors?


internal
fun FlyweightCapableTreeStructure<LighterASTNode>.getFirstChildExpressionUnwrapped(node: LighterASTNode): LighterASTNode? {

                    }
                }
            }
        """
    }

    /**
     * Configures tests to include open access to java.base/java.lang modules
     * ProjectBuilder usages will fail without this
     */
    static String addOpens() {
        """
        // Needed when using ProjectBuilder
        class AddOpensArgProvider implements CommandLineArgumentProvider {

        when:
        provider.get()

        then:
        def e2 = thrown(RuntimeException)
        e2.is(e)
        BrokenServiceImpl.attempts == 1
    }

    def "service has no max parallel usages by default"() {
        expect:
        registerService("service", ServiceImpl) {
            assert !it.maxParallelUsages.present
        }
        def registration = registry.registrations.getByName("service")

 * href="https://lorentzos.com/rxjava-as-event-bus-the-right-way-10a36bdd49ba">2</a>.) Some usages
 * of EventBus may be better written using <a
 * href="https://kotlinlang.org/docs/coroutines-guide.html">Kotlin coroutines</a>, including <a
 * href="https://kotlinlang.org/docs/flow.html">Flow</a> and <a
 * href="https://kotlinlang.org/docs/channels.html">Channels</a>. Yet other usages are better served

                is StageFailure.AssignmentErrors -> {
                    appendLine("Failures in assignments:".indent(1))
                    stageFailure.usages.forEach { unassigned ->
                        appendLine(describedUnassignedValueUsage(unassigned).indent(2))
                    }
                }

                is StageFailure.DocumentCheckFailures -> {

          if (consumer_call.getOperand(i) == op->getResult(0)) {
            argument_index = i;
            break;
          }
        }

        // Copy the const into the consumer func and replace their usages.
        func::FuncOp func = module.lookupSymbol<func::FuncOp>(function_name);

        CopyConstantIntoFunc(argument_index, op, func);
      }
    });
  }
}

}  // namespace

// If the slice is empty, it's defaulted with one token. Otherwise it just loops
// through the slice and sets the defaults for the omitempty fields that are TTL,
// Usages and Groups. Token is NOT defaulted with a random one in the API defaulting
// layer, but set to a random value later at runtime if not set before.
func SetDefaults_BootstrapTokens(obj *InitConfiguration) {

    }
  }

  // Create the new launch op after TPUCompileOp with the preprocessing ops.
  tf_device::LaunchOp moved_launch_op =
      CreateLaunchForBlock(builder, before_op, launch_block, device);

  // Replace usages of the original launch op with the new launch op for
  // operations that were moved.
  for (OpOperand& operand :
       moved_launch_op.GetBody().getTerminator()->getOpOperands()) {

        variant1.artifacts >> [artifact1]
        def publishableVariant1 = Stub(PublishableVariant)
        publishableVariant1.name >> "debug"
        publishableVariant1.usages >> [variant1]
        publishableVariant1.getCoordinates() >> new DefaultModuleVersionIdentifier("my.group", "test_app_debug", "1.2")

        def artifact2 = Stub(PublishArtifact)

	obj.ClusterConfiguration = kubeadm.ClusterConfiguration{}

	// Adds the default bootstrap token to get the round trip working
	obj.BootstrapTokens = []bootstraptokenv1.BootstrapToken{
		{
			Groups: []string{"foo"},
			Usages: []string{"foo"},
			TTL:    &metav1.Duration{Duration: 1234},
		},
	}
	obj.SkipPhases = nil
	obj.NodeRegistration.ImagePullPolicy = corev1.PullIfNotPresent
	obj.NodeRegistration.ImagePullSerial = ptr.To(true)