invalid_pattern_variable_in_shared_case_scope

The variable '{0}' doesn't have the same type and/or finality in all cases that share this body.

The variable '{0}' is available in some, but not all cases that share this body.

The variable '{0}' is not available because there is a label or 'default' case.

O analisador produz este diagnóstico quando várias cláusulas case de uma instrução switch compartilham um corpo, e pelo menos uma delas declara uma variável que é referenciada nas instruções compartilhadas, mas a variável não é declarada em todas as cláusulas case ou é declarada de formas inconsistentes.

Se a variável não for declarada em todas as cláusulas case, então ela não terá um valor caso uma das cláusulas que não declaram a variável seja a que corresponde e executa o corpo. Isso inclui a situação em que uma das cláusulas case é a cláusula default.

Se a variável for declarada de formas inconsistentes, sendo final em alguns casos e não final em outros, ou tendo tipos diferentes em casos diferentes, então a semântica do que devem ser o tipo ou a finalidade da variável não está definida.

O código a seguir produz este diagnóstico porque a variável a é declarada em apenas uma das cláusulas case e não terá um valor se a segunda cláusula for a que correspondeu a x:

void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    case 0:
      a;
  }
}

O código a seguir produz este diagnóstico porque a variável a não é declarada na cláusula default e não terá um valor se o corpo for executado, porque nenhuma das outras cláusulas correspondeu a x:

void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    default:
      a;
  }
}

O código a seguir produz este diagnóstico porque a variável a não terá um valor se o corpo for executado, pois um grupo diferente de casos fez o controle continuar no rótulo:

void f(Object? x) {
  switch (x) {
    someLabel:
    case int a when a > 0:
      a;
    case int b when b < 0:
      continue someLabel;
  }
}

O código a seguir produz este diagnóstico porque a variável a, embora seja atribuída em todas as cláusulas case, não tem o mesmo tipo associado a ela em todas as cláusulas:

void f(Object? x) {
  switch (x) {
    case int a when a < 0:
    case num a when a > 0:
      a;
  }
}

O código a seguir produz este diagnóstico porque a variável a é final na primeira cláusula case e não é final na segunda cláusula case:

void f(Object? x) {
  switch (x) {
    case final int a when a < 0:
    case int a when a > 0:
      a;
  }
}

Se a variável não for declarada em todos os casos, e você precisar referenciá-la nas instruções, então declare-a nos outros casos:

void f(Object? x) {
  switch (x) {
    case int a when a > 0:
    case int a when a == 0:
      a;
  }
}

Se a variável não for declarada em todos os casos, e você não precisar referenciá-la nas instruções, então remova as referências a ela e remova as declarações dos outros casos:

void f(int x) {
  switch (x) {
    case > 0:
    case 0:
  }
}

Se o tipo da variável for diferente, decida qual tipo a variável deve ter e torne os casos consistentes:

void f(Object? x) {
  switch (x) {
    case num a when a < 0:
    case num a when a > 0:
      a;
  }
}

Se a finalidade da variável for diferente, decida se ela deve ser final ou não e torne os casos consistentes:

void f(Object? x) {
  switch (x) {
    case final int a when a < 0:
    case final int a when a > 0:
      a;
  }
}