refactor: migrate function_lines_of_code

[solid-illiaaihistov]

No description provided.

[gemini-code-assist]

Code Review

This pull request migrates the solid_lints package from custom_lint_builder to the new analysis_server_plugin API, refactoring various lint rules as AnalysisRule subclasses and adding comprehensive reflective tests. The review feedback highlights several critical issues: a correctness bug in _isWrappedInReleaseCheck that fails to verify which branch of an IfStatement contains the debugPrint call; a pattern matching failure in UnnecessaryWhereTypeVisitor for implicit calls on this which can be resolved by using realTarget; a potential syntax error in AvoidUnnecessaryTypeAssertionsFix when whereType is called implicitly; and a directory traversal bug in _findNearestAnalysisOptionsFilePath that misses checking the root directory for analysis_options.yaml.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

There is a correctness bug in _isWrappedInReleaseCheck. It traverses up the AST to find any ancestor IfStatement with a !kReleaseMode or kDebugMode condition, but it does not verify whether the debugPrint call is actually inside the then branch or the else branch of that IfStatement.

If a debugPrint is placed inside the else branch of if (!kReleaseMode), it will run in release mode, but this visitor will incorrectly treat it as safe and fail to report it.

To fix this, we should track the child node as we traverse up and ensure the check is only considered safe if the node is in the correct branch.

  bool _isWrappedInReleaseCheck(AstNode node) {
    AstNode? current = node;
    AstNode? parent = node.parent;

    while (parent != null) {
      if (parent is IfStatement) {
        final condition = parent.expression;
        if (current == parent.thenStatement) {
          if (_isNotReleaseModeCheck(condition) || _isDebugModeCheck(condition)) {
            return true;
          }
        } else if (current == parent.elseStatement) {
          if (_isReleaseModeCheck(condition)) {
            return true;
          }
        }
      }

      current = parent;
      parent = parent.parent;
    }

    return false;
  }

  bool _isReleaseModeCheck(Expression condition) {
    return condition is SimpleIdentifier && condition.name == _kReleaseMode;
  }

[gemini-code-assist]

Using target: Expression(...) in the pattern match will fail to match when whereType is called implicitly on this (i.e., without an explicit target, like whereType<double>() inside an Iterable subclass), because target is null in the AST for implicit calls.

To fix this and avoid false negatives, we should match on realTarget instead of target, as realTarget is never null and correctly resolves to the implicit this expression.

  bool _isUnnecessaryWhereType(MethodInvocation node) {
    if (node case MethodInvocation(
      methodName: Identifier(
        name: AvoidUnnecessaryTypeAssertionsRule.whereTypeMethodName,
      ),
      realTarget: Expression(staticType: final InterfaceType targetType),
      typeArguments: TypeArgumentList(:final arguments),
    ) when arguments.isNotEmpty) {
      final targetIterableType = switch (targetType) {
        InterfaceType(isDartCoreIterable: true) => targetType,
        InterfaceType(:final allSupertypes) => allSupertypes.firstWhereOrNull(
          (e) => e.isDartCoreIterable,
        ),
      };

      final objectType = targetIterableType?.typeArguments.firstOrNull;
      final castedType = arguments.first.type;

      if (castedType == null || objectType == null) {
        return false;
      }

      final typeCast = TypeCast(source: objectType, target: castedType);

      return typeCast.isUnnecessaryTypeCheck;
    }

    return false;
  }

[gemini-code-assist]

If whereType is called implicitly on this (e.g., whereType<double>()), whereTypeNode.operator is null. In this case, operatorOffset defaults to whereTypeNode.offset, and _partToRemove covers the entire node. Deleting the entire node will result in a syntax error (e.g., final result = ;).

Instead, when there is no operator, the entire node should be replaced with 'this' to maintain syntactic and semantic correctness.

  @override
  Future<void> compute(ChangeBuilder builder) async {
    final isExpressionNode = node.thisOrAncestorOfType<IsExpression>();
    if (isExpressionNode != null) {
      final operatorOffset = isExpressionNode.isOperator.offset - 1;
      _partToRemove = _removedPartRange(isExpressionNode, operatorOffset);
    }

    final whereTypeNode = node.thisOrAncestorOfType<MethodInvocation>();
    if (whereTypeNode != null && _partToRemove == null) {
      final operator = whereTypeNode.operator;
      if (operator != null) {
        final operatorOffset = operator.offset;
        _partToRemove = _removedPartRange(whereTypeNode, operatorOffset);
      } else {
        await builder.addDartFileEdit(
          file,
          (builder) => builder.addSimpleReplacement(
            whereTypeNode.sourceRange,
            'this',
          ),
        );
        return;
      }
    }

    final partToRemove = _partToRemove;
    if (partToRemove == null) return;

    await builder.addDartFileEdit(
      file,
      (builder) => builder.addDeletion(partToRemove),
    );
  }

[gemini-code-assist]

The loop condition while (pathContext.dirname(currentDirectoryPath) != currentDirectoryPath) will terminate immediately if packageRootPath is the root directory (e.g., / or C:\), meaning it will never check for analysis_options.yaml at the root directory itself.

To make this search robust across all environments (including containers or environments where the project is at the root), we should check the current directory first before checking the loop termination condition.

  String? _findNearestAnalysisOptionsFilePath(String packageRootPath) {
    final pathContext = _resourceProvider.pathContext;
    String currentDirectoryPath = packageRootPath;

    while (true) {
      final candidatePath =
          pathContext.join(currentDirectoryPath, 'analysis_options.yaml');
      final candidateFile = _resourceProvider.getFile(candidatePath);

      if (candidateFile.exists) {
        return candidatePath;
      }

      final parentDir = pathContext.dirname(currentDirectoryPath);
      if (parentDir == currentDirectoryPath) {
        break;
      }
      currentDirectoryPath = parentDir;
    }

    return null;
  }