Failure

Engineering reasoning behind evaluation, including mitigation, independence and explicit assumptions. This is a recorded argument, not proof of sufficiency and not a substitute for mitigatedBy or independentFailures. Keep open review questions, finding details, actions and import notes in comment.

Identity of the authored Kotlin declaration, independent of its receiving model instance. Inherited declarations retain this provenance while id distinguishes each owning instance.

Fully-qualified name of the declaring context. Prefers declaringClassNameOverride (set explicitly by source materializers or canonical-ID binding) over declaringClass's captured name; falls back to null if neither is available.

Numerical diagnostic coverage as a fraction from 0 to 1 inclusive: 1.0f means 100%, 0.99f means 99%. null means unspecified or not applicable, not zero coverage. For hardware, this is the fraction of this failure mode's failure rate detected or controlled by implemented safety mechanisms (AIAG & VDA FMEA Handbook, first edition, glossary, following ISO 26262-1:2018). State the calculation basis and evidence in argument or sources. Do not substitute a percentage of software failure modes, tests or requirements.

Engineering conclusion about the sufficiency of safety measures and any justified residual contribution. See FailureEvaluation for the meanings shared by software, hardware and system analyses. null means no evaluation has been recorded yet. Model rules report HIGH unless the value is FailureEvaluation.SUFFICIENT or FailureEvaluation.RESIDUAL.

Fully-qualified unique identifier of this model instance. A member follows its actual owning instance, so two instances of the same user class have distinct member IDs. declarationId retains the common source declaration for navigation and naming rules.

For Multiplicity.MULTIPLE_POINT failures: the independent failure(s) that, in combination with this failure, can violate the safety goal. At least one entry is required when multiplicity is MULTIPLE_POINT and severity is at or above S10 or missing. A severity explicitly below S10 exempts this reference requirement, regardless of ASIL; a failure can list more than one independent alternative (e.g. several distinct failure modes that each independently combine with this one to violate the safety goal). Each alternative must belong to a different element on a separate hierarchy branch: neither element may be an ancestor of the other. A valid alternative also satisfies the S10 mitigation requirement.

Safety measures, including safety mechanisms, that mitigate this failure. The mitigation rule requires at least one measure or a valid independentFailures entry unless ASIL is explicitly QM and severity is below S10. Missing ASIL or severity does not exempt the failure.

The InterfacePointAnalysis that declares this failure as one of its properties.

Failures that this failure propagates into. Often cyclic in real safety models (feedback paths), so the source materializer needs to back-patch after both ends exist in the scope — hence var. Compiled-path callers should treat as effectively immutable.

Kotlin val name that holds this entity, scoped to its declaring context. Populated reflectively by WireModel.wireAll in the compiled path, or set directly via bindToSource in the source-materialized path. null until either runs.

Prefer Severity.S0 through Severity.S10; Severity also preserves explicitly supplied Float values.

Binds an authored field or constructor-owned value without replacing its source declaration provenance.

Registers a child entity declared inside a source-materialized parent.

Records source-declared uses without changing the target's declaration or owner.

Binds an entity to an already computed canonical MetamodelEntity.id.

Sets the canonical identifiers for an entity that was materialized from source (as opposed to being instantiated from compiled bytecode). Intended for use by PSI / source materializers such as the IDEA plugin.

Interface-point analyses in declaration order, including analyses nested beneath ports or service groups.

Structural children, including explicit metamodel containment. Relation targets retain their own declaration.