# forConstructorParameterWithImplementation static method

ResolvableType forConstructorParameterWithImplementation(

1. ConstructorDeclaration constructor,
2. int parameterIndex,
3. Type implementationClass

)

Creates a ResolvableType for a constructor parameter with implementation context.

This factory method creates a ResolvableType for a constructor parameter that considers a specific implementation class context. This is useful when the parameter type needs to be resolved in the context of a concrete implementation rather than the declaring class.

Parameters:

- `constructor`: The ConstructorDeclaration containing the parameter
- `parameterIndex`: The zero-based index of the parameter
- `implementationClass`: The implementation class Type to provide context

Returns:

- ResolvableType representing the parameter type in the implementation context
- ResolvableType.NONE if the parameter index is invalid

Example:

    abstract class Repository<T> {
      Repository(T initialValue);
    }

    class UserRepository extends Repository<User> {
      UserRepository(User user) : super(user);
    }

    final constructor = getConstructorDeclaration(Repository);

    // Without implementation context - returns T (type variable)
    final genericParamType = ResolvableType.forConstructorParameter(constructor, 0);

    // With implementation context - returns User
    final concreteParamType = ResolvableType.forConstructorParameterWithImplementation(
      constructor,
      0,
      UserRepository
    );

    print(concreteParamType.resolve()?.getType()); // User

## Implementation

    static ResolvableType forConstructorParameterWithImplementation(ConstructorDeclaration constructor, int parameterIndex, Type implementationClass) {
      final params = constructor.getParameters();
      if (parameterIndex >= 0 && parameterIndex < params.length) {
        final param = params[parameterIndex];
        final owner = forType(implementationClass);
        final resolver = owner.asVariableResolver();
        return forTypeWithProviderAndResolver(param.getType(), _ParameterTypeProvider(param), resolver);
      }
      return NONE;
    }