コード例 #1
0
 @NotNull
 protected JetTypeInfo visitAssignment(
     JetBinaryExpression expression, ExpressionTypingContext contextWithExpectedType) {
   ExpressionTypingContext context =
       contextWithExpectedType.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).replaceScope(scope);
   JetExpression left =
       context.expressionTypingServices.deparenthesize(expression.getLeft(), context);
   JetExpression right = expression.getRight();
   if (left instanceof JetArrayAccessExpression) {
     JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) left;
     if (right == null) return JetTypeInfo.create(null, context.dataFlowInfo);
     JetTypeInfo typeInfo =
         basic.resolveArrayAccessSetMethod(arrayAccessExpression, right, context, context.trace);
     basic.checkLValue(context.trace, arrayAccessExpression);
     return JetTypeInfo.create(
         checkAssignmentType(typeInfo.getType(), expression, contextWithExpectedType),
         typeInfo.getDataFlowInfo());
   }
   JetTypeInfo leftInfo = facade.getTypeInfo(expression.getLeft(), context);
   JetType leftType = leftInfo.getType();
   DataFlowInfo dataFlowInfo = leftInfo.getDataFlowInfo();
   if (right != null) {
     JetTypeInfo rightInfo =
         facade.getTypeInfo(
             right, context.replaceDataFlowInfo(dataFlowInfo).replaceExpectedType(leftType));
     dataFlowInfo = rightInfo.getDataFlowInfo();
   }
   if (leftType != null) { // if leftType == null, some another error has been generated
     basic.checkLValue(context.trace, expression.getLeft());
   }
   return DataFlowUtils.checkStatementType(expression, contextWithExpectedType, dataFlowInfo);
 }
コード例 #2
0
 @Nullable
 private JetType checkAssignmentType(
     @Nullable JetType assignmentType,
     @NotNull JetBinaryExpression expression,
     @NotNull ExpressionTypingContext context) {
   if (assignmentType != null
       && !KotlinBuiltIns.getInstance().isUnit(assignmentType)
       && context.expectedType != TypeUtils.NO_EXPECTED_TYPE
       && TypeUtils.equalTypes(context.expectedType, assignmentType)) {
     context.trace.report(Errors.ASSIGNMENT_TYPE_MISMATCH.on(expression, context.expectedType));
     return null;
   }
   return DataFlowUtils.checkStatementType(expression, context);
 }
コード例 #3
0
 @Override
 public JetTypeInfo visitClass(JetClass klass, ExpressionTypingContext context) {
   TopDownAnalyzer.processClassOrObject(
       context.expressionTypingServices.getProject(),
       context.trace,
       scope,
       scope.getContainingDeclaration(),
       klass);
   ClassDescriptor classDescriptor =
       context.trace.getBindingContext().get(BindingContext.CLASS, klass);
   if (classDescriptor != null) {
     scope.addClassifierDescriptor(classDescriptor);
   }
   return DataFlowUtils.checkStatementType(klass, context, context.dataFlowInfo);
 }
コード例 #4
0
  @Override
  public JetTypeInfo visitProperty(JetProperty property, ExpressionTypingContext context) {
    JetTypeReference receiverTypeRef = property.getReceiverTypeRef();
    if (receiverTypeRef != null) {
      context.trace.report(LOCAL_EXTENSION_PROPERTY.on(receiverTypeRef));
    }

    JetPropertyAccessor getter = property.getGetter();
    if (getter != null) {
      context.trace.report(LOCAL_VARIABLE_WITH_GETTER.on(getter));
    }

    JetPropertyAccessor setter = property.getSetter();
    if (setter != null) {
      context.trace.report(LOCAL_VARIABLE_WITH_SETTER.on(setter));
    }

    VariableDescriptor propertyDescriptor =
        context
            .expressionTypingServices
            .getDescriptorResolver()
            .resolveLocalVariableDescriptor(
                scope.getContainingDeclaration(),
                scope,
                property,
                context.dataFlowInfo,
                context.trace);
    JetExpression initializer = property.getInitializer();
    DataFlowInfo dataFlowInfo = context.dataFlowInfo;
    if (initializer != null) {
      JetType outType = propertyDescriptor.getType();
      JetTypeInfo typeInfo =
          facade.getTypeInfo(initializer, context.replaceExpectedType(outType).replaceScope(scope));
      dataFlowInfo = typeInfo.getDataFlowInfo();
    }

    {
      VariableDescriptor olderVariable = scope.getLocalVariable(propertyDescriptor.getName());
      ExpressionTypingUtils.checkVariableShadowing(context, propertyDescriptor, olderVariable);
    }

    scope.addVariableDescriptor(propertyDescriptor);
    ModifiersChecker.create(context.trace).checkModifiersForLocalDeclaration(property);
    return DataFlowUtils.checkStatementType(property, context, dataFlowInfo);
  }
コード例 #5
0
 @Override
 public JetTypeInfo visitMultiDeclaration(
     JetMultiDeclaration multiDeclaration, final ExpressionTypingContext context) {
   final JetExpression initializer = multiDeclaration.getInitializer();
   if (initializer == null) {
     context.trace.report(INITIALIZER_REQUIRED_FOR_MULTIDECLARATION.on(multiDeclaration));
     return JetTypeInfo.create(null, context.dataFlowInfo);
   }
   final ExpressionReceiver expressionReceiver =
       ExpressionTypingUtils.getExpressionReceiver(
           facade, initializer, context.replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE));
   DataFlowInfo dataFlowInfo = facade.getTypeInfo(initializer, context).getDataFlowInfo();
   if (expressionReceiver == null) {
     return JetTypeInfo.create(null, dataFlowInfo);
   }
   ExpressionTypingUtils.defineLocalVariablesFromMultiDeclaration(
       scope, multiDeclaration, expressionReceiver, initializer, context);
   return DataFlowUtils.checkStatementType(multiDeclaration, context, dataFlowInfo);
 }
コード例 #6
0
 @Override
 public JetTypeInfo visitObjectDeclaration(
     JetObjectDeclaration declaration, ExpressionTypingContext context) {
   TopDownAnalyzer.processClassOrObject(
       context.expressionTypingServices.getProject(),
       context.trace,
       scope,
       scope.getContainingDeclaration(),
       declaration);
   ClassDescriptor classDescriptor =
       context.trace.getBindingContext().get(BindingContext.CLASS, declaration);
   if (classDescriptor != null) {
     VariableDescriptor variableDescriptor =
         context
             .expressionTypingServices
             .getDescriptorResolver()
             .resolveObjectDeclaration(
                 scope.getContainingDeclaration(), declaration, classDescriptor, context.trace);
     scope.addVariableDescriptor(variableDescriptor);
   }
   return DataFlowUtils.checkStatementType(declaration, context, context.dataFlowInfo);
 }
コード例 #7
0
  @Override
  public JetTypeInfo visitNamedFunction(
      JetNamedFunction function, ExpressionTypingContext context) {
    SimpleFunctionDescriptor functionDescriptor =
        context
            .expressionTypingServices
            .getDescriptorResolver()
            .resolveFunctionDescriptor(
                scope.getContainingDeclaration(), scope, function, context.trace);

    scope.addFunctionDescriptor(functionDescriptor);
    JetScope functionInnerScope =
        FunctionDescriptorUtil.getFunctionInnerScope(
            context.scope, functionDescriptor, context.trace);
    context.expressionTypingServices.checkFunctionReturnType(
        functionInnerScope,
        function,
        functionDescriptor,
        context.dataFlowInfo,
        null,
        context.trace);
    ModifiersChecker.create(context.trace).checkModifiersForLocalDeclaration(function);
    return DataFlowUtils.checkStatementType(function, context, context.dataFlowInfo);
  }
コード例 #8
0
 @Override
 public JetTypeInfo visitDeclaration(JetDeclaration dcl, ExpressionTypingContext context) {
   return DataFlowUtils.checkStatementType(dcl, context, context.dataFlowInfo);
 }