Example #1
0
 private IType getReturnType() {
   ICPPASTFunctionDeclarator lambdaDtor = fLambdaExpression.getDeclarator();
   if (lambdaDtor != null) {
     IASTTypeId trailingReturnType = lambdaDtor.getTrailingReturnType();
     if (trailingReturnType != null) {
       return CPPVisitor.createType(trailingReturnType);
     }
   }
   IASTCompoundStatement body = fLambdaExpression.getBody();
   if (body != null) {
     IASTStatement[] stmts = body.getStatements();
     if (stmts.length > 0) {
       // Gnu extension allows to deduce return type in complex compound statements
       IASTStatement stmt = stmts[stmts.length - 1];
       if (stmt instanceof IASTReturnStatement) {
         IASTReturnStatement rtstmt = (IASTReturnStatement) stmt;
         IASTExpression expr = rtstmt.getReturnValue();
         if (expr != null) {
           IType type = expr.getExpressionType();
           type = Conversions.lvalue_to_rvalue(type, false);
           if (type != null) {
             return type;
           }
         }
       }
     }
   }
   return CPPSemantics.VOID_TYPE;
 }
Example #2
0
 private IType[] getParameterTypes() {
   ICPPASTFunctionDeclarator lambdaDtor = fLambdaExpression.getDeclarator();
   if (lambdaDtor != null) {
     return CPPVisitor.createParameterTypes(lambdaDtor);
   }
   return IType.EMPTY_TYPE_ARRAY;
 }
Example #3
0
  private ICPPMethod[] createMethods() {
    boolean needConversionOperator =
        fLambdaExpression.getCaptureDefault() == CaptureDefault.UNSPECIFIED
            && fLambdaExpression.getCaptures().length == 0;

    final ICPPClassScope scope = getCompositeScope();
    ICPPMethod[] result = new ICPPMethod[needConversionOperator ? 6 : 5];

    // Deleted default constructor: A()
    CPPImplicitConstructor ctor =
        new CPPImplicitConstructor(
            scope, CharArrayUtils.EMPTY, ICPPParameter.EMPTY_CPPPARAMETER_ARRAY);
    ctor.setDeleted(true);
    result[0] = ctor;

    // Copy constructor: A(const A &)
    IType pType = new CPPReferenceType(SemanticUtil.constQualify(this), false);
    ICPPParameter[] ps = new ICPPParameter[] {new CPPParameter(pType, 0)};
    ctor = new CPPImplicitConstructor(scope, CharArrayUtils.EMPTY, ps);
    result[1] = ctor;

    // Deleted copy assignment operator: A& operator = (const A &)
    IType refType = new CPPReferenceType(this, false);
    ICPPFunctionType ft = CPPVisitor.createImplicitFunctionType(refType, ps, false, false);
    ICPPMethod m = new CPPImplicitMethod(scope, OverloadableOperator.ASSIGN.toCharArray(), ft, ps);
    result[2] = m;

    // Destructor: ~A()
    ft =
        CPPVisitor.createImplicitFunctionType(
            NO_RETURN_TYPE, ICPPParameter.EMPTY_CPPPARAMETER_ARRAY, false, false);
    m = new CPPImplicitMethod(scope, new char[] {'~'}, ft, ICPPParameter.EMPTY_CPPPARAMETER_ARRAY);
    result[3] = m;

    // Function call operator
    final IType returnType = getReturnType();
    final IType[] parameterTypes = getParameterTypes();
    ft = new CPPFunctionType(returnType, parameterTypes, !isMutable(), false, false);

    ICPPParameter[] params = new ICPPParameter[parameterTypes.length];
    for (int i = 0; i < params.length; i++) {
      params[i] = new CPPParameter(parameterTypes[i], i);
    }
    m =
        new CPPImplicitMethod(scope, OverloadableOperator.PAREN.toCharArray(), ft, params) {
          @Override
          public boolean isImplicit() {
            return false;
          }
        };
    result[4] = m;

    // Conversion operator
    if (needConversionOperator) {
      final CPPFunctionType conversionTarget = new CPPFunctionType(returnType, parameterTypes);
      ft = new CPPFunctionType(conversionTarget, IType.EMPTY_TYPE_ARRAY, true, false, false);
      m =
          new CPPImplicitMethod(
              scope, CPPASTConversionName.createName(conversionTarget, null), ft, params);
      result[5] = m;
    }
    return result;
  }
Example #4
0
 private boolean isMutable() {
   ICPPASTFunctionDeclarator lambdaDtor = fLambdaExpression.getDeclarator();
   return lambdaDtor != null && lambdaDtor.isMutable();
 }