<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Test: Partial Linkage JS / no IC" type="GradleRunConfiguration" factoryName="Gradle" folderName="Tests">
    <ExternalSystemSettings>
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$" />
      <option name="externalSystemIdString" value="GRADLE" />
      <option name="scriptParameters" value="--stacktrace" />

  }

  @Test
  @TestMetadata("boolean_partial.kt")
  public void testBoolean_partial() {
    runTest("analysis/analysis-api/testData/components/expressionInfoProvider/whenMissingCases/boolean_partial.kt");
  }

  @Test
  @TestMetadata("enum_else.kt")
  public void testEnum_else() {

    And many teams use only `PUT`, even for partial updates.

    You are **free** to use them however you want, **FastAPI** doesn't impose any restrictions.

    But this guide shows you, more or less, how they are intended to be used.

### Using Pydantic's `exclude_unset` parameter

    override fun resolveToSymbols(reference: KtReference): Collection<KtSymbol> {
        require(reference is KtFe10Reference)
        val bindingContext = analysisContext.analyze(reference.element, Fe10AnalysisFacade.AnalysisMode.PARTIAL)
        return reference.getTargetDescriptors(bindingContext).mapNotNull { descriptor ->
            descriptor.toKtSymbol(analysisContext)
        }
    }

        return analyze(listOf(element), mode)
    }

    fun getOrigin(file: VirtualFile): KtSymbolOrigin

    enum class AnalysisMode {
        ALL_COMPILER_CHECKS,
        FULL,
        PARTIAL_WITH_DIAGNOSTICS,
        PARTIAL
    }
}

class Fe10AnalysisContext(
    facade: Fe10AnalysisFacade,
    val resolveSession: ResolveSession,
    val deprecationResolver: DeprecationResolver,
    val callResolver: CallResolver,

        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        bindingContext[BindingContext.VALUE_PARAMETER, psi]
    }

    override val generatedPrimaryConstructorProperty: KtKotlinPropertySymbol? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)

        if (unwrapped.getParentOfTypes(false, *NON_EXPRESSION_CONTAINERS) != null) {
            return null
        }

        val bindingContext = analysisContext.analyze(unwrapped, AnalysisMode.PARTIAL)
        val smartCastType = when (val smartCastType = bindingContext[BindingContext.SMARTCAST, expression]) {
            is SingleSmartCast -> smartCastType.type

) : KtKotlinPropertySymbol(), KtFe10PsiSymbol<KtProperty, PropertyDescriptor> {
    override val descriptor: PropertyDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        bindingContext[BindingContext.VARIABLE, psi] as? PropertyDescriptor
    }

    override val isLateInit: Boolean
        get() = withValidityAssertion { psi.hasModifier(KtTokens.LATEINIT_KEYWORD) }

    return nullptr;
  }
  tensorflow::PartialTensorShape partial_shape;
  if (shape.num_dims != -1) {
    DCHECK(shape.dim_sizes != nullptr);
    Status status = tensorflow::PartialTensorShape::MakePartialShape(
        reinterpret_cast<int64_t*>(shape.dim_sizes), shape.num_dims,
        &partial_shape);
    if (!status.ok()) {
      tsl::Set_TF_Status_from_Status(s, status);

 * <ol>
 * <li>success - in which case only the model field is set
 * <li>success with warnings - model field + non-error model problems
 * <li>error - no model, but diagnostics
 * <li>error - (partial) model and diagnostics
 * </ol>
 * Could encode these variants as subclasses, but kept in one for now
 *
 * @param <T> the model type
 */
public class Result<T> {

    /**
     * Success without warnings