Exemplo n.º 1
0
  private PsiBuilder.Marker parseFunctionTypeContents() {
    assert _at(LPAR) : tt();
    PsiBuilder.Marker functionType = mark();

    //        advance(); // LPAR
    //
    //        int lastLPar = findLastBefore(TokenSet.create(LPAR), TokenSet.create(COLON), false);
    //        if (lastLPar >= 0 && lastLPar > myBuilder.getCurrentOffset()) {
    //            TODO : -1 is a hack?
    //            createTruncatedBuilder(lastLPar - 1).parseTypeRef();
    //            advance(); // DOT
    //        }

    parseValueParameterList(true, TokenSet.EMPTY);

    //        if (at(COLON)) {
    //            advance(); // COLON // expect(COLON, "Expecting ':' followed by a return type",
    // TYPE_REF_FIRST);

    expect(ARROW, "Expecting '->' to specify return type of a function type", TYPE_REF_FIRST);
    parseTypeRef();
    //        }

    return functionType; // .done(FUNCTION_TYPE);
  }
Exemplo n.º 2
0
  /*
   * class
   *   : modifiers ("class" | "trait") SimpleName
   *       typeParameters?
   *         modifiers ("(" primaryConstructorParameter{","} ")")?
   *       (":" attributes delegationSpecifier{","})?
   *       typeConstraints
   *       (classBody? | enumClassBody)
   *   ;
   */
  IElementType parseClass(boolean enumClass) {
    assert _atSet(CLASS_KEYWORD, TRAIT_KEYWORD);
    advance(); // CLASS_KEYWORD or TRAIT_KEYWORD

    if (!parseIdeTemplate()) {
      expect(IDENTIFIER, "Class name expected", CLASS_NAME_RECOVERY_SET);
    }
    boolean typeParametersDeclared = parseTypeParameterList(TYPE_PARAMETER_GT_RECOVERY_SET);

    PsiBuilder.Marker beforeConstructorModifiers = mark();
    boolean hasConstructorModifiers = parseModifierList(PRIMARY_CONSTRUCTOR_MODIFIER_LIST, false);

    // Some modifiers found, but no parentheses following: class has already ended, and we are
    // looking at something else
    if (hasConstructorModifiers && !atSet(LPAR, LBRACE, COLON)) {
      beforeConstructorModifiers.rollbackTo();
      return CLASS;
    }

    // We are still inside a class declaration
    beforeConstructorModifiers.drop();

    if (at(LPAR)) {
      parseValueParameterList(false, TokenSet.create(COLON, LBRACE));
    } else if (hasConstructorModifiers) {
      // A comprehensive error message for cases like:
      //    class A private : Foo
      // or
      //    class A private {
      error("Expecting primary constructor parameter list");
    }

    if (at(COLON)) {
      advance(); // COLON
      parseDelegationSpecifierList();
    }

    parseTypeConstraintsGuarded(typeParametersDeclared);

    if (at(LBRACE)) {
      if (enumClass) {
        parseEnumClassBody();
      } else {
        parseClassBody();
      }
    }

    return CLASS;
  }
Exemplo n.º 3
0
  /*
   * function
   *   : modifiers "fun" typeParameters?
   *       (type "." | attributes)?
   *       SimpleName
   *       typeParameters? functionParameters (":" type)?
   *       typeConstraints
   *       functionBody?
   *   ;
   */
  IElementType parseFunction() {
    assert _at(FUN_KEYWORD);

    advance(); // FUN_KEYWORD

    // Recovery for the case of class A { fun| }
    if (at(RBRACE)) {
      error("Function body expected");
      return FUN;
    }

    boolean typeParameterListOccurred = false;
    if (at(LT)) {
      parseTypeParameterList(TokenSet.create(LBRACKET, LBRACE, LPAR));
      typeParameterListOccurred = true;
    }

    myBuilder.disableJoiningComplexTokens();
    int lastDot = findLastBefore(RECEIVER_TYPE_TERMINATORS, TokenSet.create(LPAR), true);

    TokenSet functionNameFollow = TokenSet.create(LT, LPAR, COLON, EQ);
    parseReceiverType("function", functionNameFollow, lastDot);

    parseFunctionOrPropertyName(lastDot != -1, "function", functionNameFollow);

    myBuilder.restoreJoiningComplexTokensState();

    TokenSet valueParametersFollow = TokenSet.create(COLON, EQ, LBRACE, SEMICOLON, RPAR);

    if (at(LT)) {
      PsiBuilder.Marker error = mark();
      parseTypeParameterList(TokenSet.orSet(TokenSet.create(LPAR), valueParametersFollow));
      errorIf(
          error,
          typeParameterListOccurred,
          "Only one type parameter list is allowed for a function");
      typeParameterListOccurred = true;
    }

    if (at(LPAR)) {
      parseValueParameterList(false, valueParametersFollow);
    } else {
      error("Expecting '('");
    }

    if (at(COLON)) {
      advance(); // COLON

      if (!parseIdeTemplate()) {
        parseTypeRef();
      }
    }

    parseTypeConstraintsGuarded(typeParameterListOccurred);

    if (at(SEMICOLON)) {
      advance(); // SEMICOLON
    } else if (at(EQ) || at(LBRACE)) {
      parseFunctionBody();
    }

    return FUN;
  }