jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java

-:1fe358ea75ff
+:5f915a0c9615
 * deserialize method parameter symbol
 */
 private final VarSymbol deserParamSym;
 private KlassInfo(Symbol kSym) {
-appendedMethodList = ListBuffer.lb();
+appendedMethodList = new ListBuffer<>();
 deserializeCases = new HashMap<String, ListBuffer<JCStatement>>();
 long flags = PRIVATE | STATIC | SYNTHETIC;
 MethodType type = new MethodType(List.of(syms.serializedLambdaType), syms.objectType,
 List.<Type>nil(), syms.methodClass);
 deserMethodSym = makeSyntheticMethod(flags, names.deserializeLambda, type, kSym);
 context = prevContext;
 }
 }
 <T extends JCTree> List<T> translate(List<T> trees, TranslationContext<?> newContext) {
-ListBuffer<T> buf = ListBuffer.lb();
+ListBuffer<T> buf = new ListBuffer<>();
 for (T tree : trees) {
 buf.append(translate(tree, newContext));
 }
 return buf.toList();
 }
 //should be added the following synthetic arguments:
 //
 // * the "this" argument if it is an instance method
 // * enclosing locals captured by the lambda expression
-ListBuffer<JCExpression> syntheticInits = ListBuffer.lb();
+ListBuffer<JCExpression> syntheticInits = new ListBuffer<>();
 if (!sym.isStatic()) {
 syntheticInits.append(makeThis(
 sym.owner.enclClass().asType(),
 localContext.owner.enclClass()));
 JCStatement stat = make.Exec(expr);
 return make.Block(0, List.<JCStatement>of(stat));
 } else if (isLambda_void && isTarget_Void) {
 //void to Void conversion:
 // BODY; return null;
-ListBuffer<JCStatement> stats = ListBuffer.lb();
+ListBuffer<JCStatement> stats = new ListBuffer<>();
 stats.append(make.Exec(expr));
 stats.append(make.Return(make.Literal(BOT, null).setType(syms.botType)));
 return make.Block(0, stats.toList());
 } else {
 //non-void to non-void conversion:
 }
 return trans_block;
 }
 private JCMethodDecl makeDeserializeMethod(Symbol kSym) {
-ListBuffer<JCCase> cases = ListBuffer.lb();
+ListBuffer<JCCase> cases = new ListBuffer<>();
-ListBuffer<JCBreak> breaks = ListBuffer.lb();
+ListBuffer<JCBreak> breaks = new ListBuffer<>();
 for (Map.Entry<String, ListBuffer<JCStatement>> entry : kInfo.deserializeCases.entrySet()) {
 JCBreak br = make.Break(null);
 breaks.add(br);
 List<JCStatement> stmts = entry.getValue().append(br).toList();
 cases.add(make.Case(make.Literal(entry.getKey()), stmts));
 String implClass = classSig(types.erasure(refSym.owner.type));
 String implMethodName = refSym.getQualifiedName().toString();
 String implMethodSignature = methodSig(types.erasure(refSym.type));
 JCExpression kindTest = eqTest(syms.intType, deserGetter("getImplMethodKind", syms.intType), make.Literal(implMethodKind));
-ListBuffer<JCExpression> serArgs = ListBuffer.lb();
+ListBuffer<JCExpression> serArgs = new ListBuffer<>();
 int i = 0;
 for (Type t : indyType.getParameterTypes()) {
-List<JCExpression> indexAsArg = ListBuffer.<JCExpression>lb().append(make.Literal(i)).toList();
+List<JCExpression> indexAsArg = new ListBuffer<JCExpression>().append(make.Literal(i)).toList();
-List<Type> argTypes = ListBuffer.<Type>lb().append(syms.intType).toList();
+List<Type> argTypes = new ListBuffer<Type>().append(syms.intType).toList();
 serArgs.add(make.TypeCast(types.erasure(t), deserGetter("getCapturedArg", syms.objectType, argTypes, indexAsArg)));
 ++i;
 }
 JCStatement stmt = make.If(
 deserTest(deserTest(deserTest(deserTest(deserTest(
 names.altMetafactory,
 staticArgs, indyType, serArgs.toList(), samSym.name)),
 null);
 ListBuffer<JCStatement> stmts = kInfo.deserializeCases.get(implMethodName);
 if (stmts == null) {
-stmts = ListBuffer.lb();
+stmts = new ListBuffer<>();
 kInfo.deserializeCases.put(implMethodName, stmts);
 }
 /****
 System.err.printf("+++++++++++++++++\n");
 System.err.printf("*functionalInterfaceClass: '%s'\n", functionalInterfaceClass);
 */
 private class MemberReferenceBridger {
 private final JCMemberReference tree;
 private final ReferenceTranslationContext localContext;
-private final ListBuffer<JCExpression> args = ListBuffer.lb();
+private final ListBuffer<JCExpression> args = new ListBuffer<>();
-private final ListBuffer<JCVariableDecl> params = ListBuffer.lb();
+private final ListBuffer<JCVariableDecl> params = new ListBuffer<>();
 MemberReferenceBridger(JCMemberReference tree, ReferenceTranslationContext localContext) {
 this.tree = tree;
 this.localContext = localContext;
 }
 typeToMethodType(samSym.type),
 new Pool.MethodHandle(refKind, refSym, types),
 typeToMethodType(tree.getDescriptorType(types)));
 //computed indy arg types
-ListBuffer<Type> indy_args_types = ListBuffer.lb();
+ListBuffer<Type> indy_args_types = new ListBuffer<>();
 for (JCExpression arg : indy_args) {
 indy_args_types.append(arg.type);
 }
 //finally, compute the type of the indy call
 Name metafactoryName = context.needsAltMetafactory() ?
 names.altMetafactory : names.metafactory;
 if (context.needsAltMetafactory()) {
-ListBuffer<Object> markers = ListBuffer.lb();
+ListBuffer<Object> markers = new ListBuffer<>();
 for (Type t : tree.targets.tail) {
 if (t.tsym != syms.serializableType.tsym) {
 markers.append(t.tsym);
 }
 }
 make.at(prevPos);
 }
 }
 //where
 private List<Type> bsmStaticArgToTypes(List<Object> args) {
-ListBuffer<Type> argtypes = ListBuffer.lb();
+ListBuffer<Type> argtypes = new ListBuffer<>();
 for (Object arg : args) {
 argtypes.append(bsmStaticArgToType(arg));
 }
 return argtypes.toList();
 }
 translatedSym.flags_field = SYNTHETIC |
 ((inInterface && thisReferenced)? PUBLIC : PRIVATE) |
 (thisReferenced? (inInterface? DEFAULT : 0) : STATIC);
 //compute synthetic params
-ListBuffer<JCVariableDecl> params = ListBuffer.lb();
+ListBuffer<JCVariableDecl> params = new ListBuffer<>();
 // The signature of the method is augmented with the following
 // synthetic parameters:
 //
 // 1) reference to enclosing contexts captured by the lambda expression

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java

src/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java