avoid-unnecessary-type-assertions

// Test cases for avoid-unnecessary-type-assertions rule
// Flags 'is T' checks where the variable is already known to be T

void testExplicitIntType() {
  final int x = 5;
  if (x is int) {
    print("x is int");
  }
}

void testExplicitStringType() {
  final String name = "hello";
  if (name is String) {
    print("name is string");
  }
}

void testExplicitListType() {
  final List<String> items = [];
  if (items is List) {
    print("items is list");
  }
}

void testMultipleUnnecessaryAssertions() {
  final bool active = true;
  final double value = 3.14;

  if (active is bool) {
    print("active is bool");
  }

  if (value is double) {
    print("value is double");
  }
}

class MyClass {
  final int id = 42;

  void checkId() {
    if (id is int) {
      print("id is int");
    }
  }
}

void testInlineAssertion() {
  final String message = "test";
  final result = message is String ? "yes" : "no";
}

// Regression: a nested block inherits the enclosing declarations, so a
// redundant assertion inside one is still recognised.
void nestedScopeRegression() {
  final int known = 1;
  {
    final inBlock = known is int;
    print(inBlock);
  }
  lbl: {
    final inLabeled = known is int;
    print(inLabeled);
  }
}

// Regression: try/catch/finally bodies also inherit the enclosing
// declarations, the same way a plain nested block does.
void tryScopeRegression() {
  final int known = 1;
  try {
    print(known is int);
  } catch (e) {
    print(known is int);
  } finally {
    print(known is int);
  }
}

void typedCollectionForAssertionRegression() {
  final list = [
    for (int i = 0; i < 2; i++) i is int,
  ];
  final map = {
    for (int j = 0; j < 2; j++) j: j is int,
  };
  print([list, map]);
}

// Initializing an `int?` local with an `int` promotes it to `int`; Dart 3.13.5
// `dart analyze` reports unnecessary_type_check here.
void testCheckPromotedOnInitialization() {
  int? maybeInt = 5;
  if (maybeInt is int) {
    print("maybeInt is int");
  }
}