groovy-notifications mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Eric Milles (JIRA)" <j...@apache.org>
Subject [jira] [Comment Edited] (GROOVY-9058) each parameter type not correctly inferenced
Date Wed, 03 Apr 2019 14:29:00 GMT

    [ https://issues.apache.org/jira/browse/GROOVY-9058?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16808751#comment-16808751
] 

Eric Milles edited comment on GROOVY-9058 at 4/3/19 2:28 PM:
-------------------------------------------------------------

In order to preserve the type checking of assignments, I think it best to make some kind of
change after {{typeCheckAssignment}} in {{StaticTypeCheckingVisitor.visitBinaryExpression}},
instead of suggested changes to {{getResultType}}.  Here is the current code for handling
assignments:

{code:java}
            if (!isEmptyDeclaration && isAssignment(op)) {
                if (rightExpression instanceof ConstructorCallExpression) {
                    inferDiamondType((ConstructorCallExpression) rightExpression, lType);
                }

                ClassNode originType = getOriginalDeclarationType(leftExpression);
                typeCheckAssignment(expression, leftExpression, originType, rightExpression,
resultType);
                // if assignment succeeds but result type is not a subtype of original type,
then we are in a special cast handling
                // and we must update the result type
                if (!implementsInterfaceOrIsSubclassOf(getWrapper(resultType), getWrapper(originType)))
{
                    resultType = originType;
                } else if (lType.isUsingGenerics() && !lType.isEnum() && hasRHSIncompleteGenericTypeInfo(resultType))
{
                    // for example, LHS is List<ConcreteClass> and RHS is List<T>
where T is a placeholder
                    resultType = lType;
                }

                // make sure we keep primitive types
                if (isPrimitiveType(originType) && resultType.equals(getWrapper(originType)))
{
                    resultType = originType;
                }

                // if we are in an if/else branch, keep track of assignment
                if (typeCheckingContext.ifElseForWhileAssignmentTracker != null &&
leftExpression instanceof VariableExpression
                        && !isNullConstant(rightExpression)) {
                    Variable accessedVariable = ((VariableExpression) leftExpression).getAccessedVariable();
                    if (accessedVariable instanceof Parameter) {
                        accessedVariable = new ParameterVariableExpression((Parameter) accessedVariable);
                    }
                    if (accessedVariable instanceof VariableExpression) {
                        VariableExpression var = (VariableExpression) accessedVariable;
                        List<ClassNode> types = typeCheckingContext.ifElseForWhileAssignmentTracker.get(var);
                        if (types == null) {
                            types = new LinkedList<ClassNode>();
                            ClassNode type = var.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
                            types.add(type);
                            typeCheckingContext.ifElseForWhileAssignmentTracker.put(var, types);
                        }
                        types.add(resultType);
                    }
                }
                storeType(leftExpression, resultType);
{code}

To preserve the declared type of a variable, another check should be added after typeCheckAssignment.
 _Does it seem sensible that the inferred type of both the variable and the binary expression
as a whole should be the declared type (that is {{Type}} in {{Type var = value}} and not whatever
{{value}} infers to)?_  If yes, {{resultType}} needs to be set to {{originType}} or {{lType}}
under some new condition.


was (Author: emilles):
In order to preserve the type checking of assignments, I think it best to make some kind of
change after {{typeCheckAssignment}} in {{StaticTypeCheckingVisitor.visitBinaryExpression}},
instead of suggested changes to {{getResultType}}.  Here is the current code for handling
assignments:

{code:java}
            if (!isEmptyDeclaration && isAssignment(op)) {
                if (rightExpression instanceof ConstructorCallExpression) {
                    inferDiamondType((ConstructorCallExpression) rightExpression, lType);
                }

                ClassNode originType = getOriginalDeclarationType(leftExpression);
                typeCheckAssignment(expression, leftExpression, originType, rightExpression,
resultType);
                // if assignment succeeds but result type is not a subtype of original type,
then we are in a special cast handling
                // and we must update the result type
                if (!implementsInterfaceOrIsSubclassOf(getWrapper(resultType), getWrapper(originType)))
{
                    resultType = originType;
                } else if (lType.isUsingGenerics() && !lType.isEnum() && hasRHSIncompleteGenericTypeInfo(resultType))
{
                    // for example, LHS is List<ConcreteClass> and RHS is List<T>
where T is a placeholder
                    resultType = lType;
                }

                // make sure we keep primitive types
                if (isPrimitiveType(originType) && resultType.equals(getWrapper(originType)))
{
                    resultType = originType;
                }

                // if we are in an if/else branch, keep track of assignment
                if (typeCheckingContext.ifElseForWhileAssignmentTracker != null &&
leftExpression instanceof VariableExpression
                        && !isNullConstant(rightExpression)) {
                    Variable accessedVariable = ((VariableExpression) leftExpression).getAccessedVariable();
                    if (accessedVariable instanceof Parameter) {
                        accessedVariable = new ParameterVariableExpression((Parameter) accessedVariable);
                    }
                    if (accessedVariable instanceof VariableExpression) {
                        VariableExpression var = (VariableExpression) accessedVariable;
                        List<ClassNode> types = typeCheckingContext.ifElseForWhileAssignmentTracker.get(var);
                        if (types == null) {
                            types = new LinkedList<ClassNode>();
                            ClassNode type = var.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
                            types.add(type);
                            typeCheckingContext.ifElseForWhileAssignmentTracker.put(var, types);
                        }
                        types.add(resultType);
                    }
                }
                storeType(leftExpression, resultType);
{code}

To preserve the declared type of a variable, another check should be added after typeCheckAssignment.
 Does it seem sensible that the inferred type of both the variable and the binary expression
as a whole should both be the declared type (that is {{Type}} in {{Type var = value}} and
not whatever {{value}} infers to)?  If yes, {{resultType}} needs to be set to {{originType}}
or {{lType}} under some new condition.

> each parameter type not correctly inferenced
> --------------------------------------------
>
>                 Key: GROOVY-9058
>                 URL: https://issues.apache.org/jira/browse/GROOVY-9058
>             Project: Groovy
>          Issue Type: Bug
>          Components: Static compilation
>    Affects Versions: 2.5.6
>            Reporter: Mauro Molinari
>            Priority: Major
>
> Consider this Java class:
> {code:java}
> package test51;
> import java.util.List;
> public class Foo {
>     public List<Object[]> bar() { return null; }
> }{code}
>  and this Groovy class:
> {code:java}
> package test51
> import groovy.transform.CompileStatic
> @CompileStatic
> class Test51 {
>     protected void foo() {
>         List<Object[]> foo = new Foo().bar()
>         foo.each { row ->
>             def o = row[0]
>         }
>     }
>     
>     List bar() {
>     }
> }{code}
> This produces a compiler error because {{row}} is resolved as {{Object}} rather than
{{Object[]}}.
> A workaround is to declare {{row}} as {{Object[] row}} in the closure parameter list.



--
This message was sent by Atlassian JIRA
(v7.6.3#76005)

Mime
View raw message