src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java
changeset 59285 7799a51dbe30
parent 59021 cfc7bb9a5a92
equal deleted inserted replaced
59284:88502b1cf76f 59285:7799a51dbe30
   891         }
   891         }
   892     }
   892     }
   893 
   893 
   894     /*  Expression2Rest = {infixop Expression3}
   894     /*  Expression2Rest = {infixop Expression3}
   895      *                  | Expression3 instanceof Type
   895      *                  | Expression3 instanceof Type
       
   896      *                  | Expression3 instanceof Pattern
   896      *  infixop         = "||"
   897      *  infixop         = "||"
   897      *                  | "&&"
   898      *                  | "&&"
   898      *                  | "|"
   899      *                  | "|"
   899      *                  | "^"
   900      *                  | "^"
   900      *                  | "&"
   901      *                  | "&"
   913         odStack[0] = t;
   914         odStack[0] = t;
   914         int startPos = token.pos;
   915         int startPos = token.pos;
   915         Token topOp = Tokens.DUMMY;
   916         Token topOp = Tokens.DUMMY;
   916         while (prec(token.kind) >= minprec) {
   917         while (prec(token.kind) >= minprec) {
   917             opStack[top] = topOp;
   918             opStack[top] = topOp;
   918             top++;
   919 
   919             topOp = token;
   920             if (token.kind == INSTANCEOF) {
   920             nextToken();
   921                 int pos = token.pos;
   921             odStack[top] = (topOp.kind == INSTANCEOF) ? parseType() : term3();
   922                 nextToken();
       
   923                 JCTree pattern = parseType();
       
   924                 if (token.kind == IDENTIFIER) {
       
   925                     checkSourceLevel(token.pos, Feature.PATTERN_MATCHING_IN_INSTANCEOF);
       
   926                     pattern = toP(F.at(token.pos).BindingPattern(ident(), pattern));
       
   927                 }
       
   928                 odStack[top] = F.at(pos).TypeTest(odStack[top], pattern);
       
   929             } else {
       
   930                 topOp = token;
       
   931                 nextToken();
       
   932                 top++;
       
   933                 odStack[top] = term3();
       
   934             }
   922             while (top > 0 && prec(topOp.kind) >= prec(token.kind)) {
   935             while (top > 0 && prec(topOp.kind) >= prec(token.kind)) {
   923                 odStack[top-1] = makeOp(topOp.pos, topOp.kind, odStack[top-1],
   936                 odStack[top - 1] = F.at(topOp.pos).Binary(optag(topOp.kind), odStack[top - 1], odStack[top]);
   924                                         odStack[top]);
       
   925                 top--;
   937                 top--;
   926                 topOp = opStack[top];
   938                 topOp = opStack[top];
   927             }
   939             }
   928         }
   940         }
   929         Assert.check(top == 0);
   941         Assert.check(top == 0);
   936         odStackSupply.add(odStack);
   948         odStackSupply.add(odStack);
   937         opStackSupply.add(opStack);
   949         opStackSupply.add(opStack);
   938         return t;
   950         return t;
   939     }
   951     }
   940     //where
   952     //where
   941         /** Construct a binary or type test node.
       
   942          */
       
   943         private JCExpression makeOp(int pos,
       
   944                                     TokenKind topOp,
       
   945                                     JCExpression od1,
       
   946                                     JCExpression od2)
       
   947         {
       
   948             if (topOp == INSTANCEOF) {
       
   949                 return F.at(pos).TypeTest(od1, od2);
       
   950             } else {
       
   951                 return F.at(pos).Binary(optag(topOp), od1, od2);
       
   952             }
       
   953         }
       
   954         /** If tree is a concatenation of string literals, replace it
   953         /** If tree is a concatenation of string literals, replace it
   955          *  by a single literal representing the concatenated string.
   954          *  by a single literal representing the concatenated string.
   956          */
   955          */
   957         protected JCExpression foldStrings(JCExpression tree) {
   956         protected JCExpression foldStrings(JCExpression tree) {
   958             if (!allowStringFolding)
   957             if (!allowStringFolding)