Quick fix create method generics fails

[CrispyDrone]

Issue Type: Bug

1. Use a method using generics in java without first declaring it
2. Use the quick fix (ctrl + .) option to create the method

This results in a method signature and body being generated without the necessary generic parameters.

VS Code version: Code 1.30.2 (61122f88f0bf01e2ac16bdb9e1bc4571755f5bd8, 2019-01-07T22:54:13.295Z)
OS version: Windows_NT x64 6.1.7601

System Info

Item	Value
CPUs	Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz (8 x 3392)
GPU Status	2d_canvas: enabled checker_imaging: disabled_off flash_3d: enabled flash_stage3d: enabled flash_stage3d_baseline: enabled gpu_compositing: enabled multiple_raster_threads: enabled_on native_gpu_memory_buffers: disabled_software rasterization: enabled video_decode: enabled video_encode: enabled webgl: enabled webgl2: enabled
Memory (System)	7.94GB (2.27GB free)
Process Argv
Screen Reader	no
VM	0%

Extensions (10)

Extension	Author (truncated)	Version
csharpextensions	jch	1.3.0
csharp	ms-	1.17.1
java	red	0.38.0
LiveServer	rit	5.3.1
vscode-java-debug	vsc	0.16.0
vscode-java-dependency	vsc	0.3.0
vscode-java-pack	vsc	0.5.0
vscode-java-test	vsc	0.14.0
vscode-maven	vsc	0.14.1
vim	vsc	1.0.6

[fbricon]

Please provide the code of the whole file, so we can reproduce the problem in the same conditions

[CrispyDrone]

When writing a non-existing method inside a generic method, and using its parameters, making use of quick fix "create method" will result in a method that is missing the generic parameters from its signature. So for example:

adding the following line:

MyMethod(seller, sellerId);

inside

    public <T1, T2> Boolean ConfirmTransaction(T2 seller, UUID sellerId, UUID transactionId)
    {
        if (!VerifyTransactionPartner(seller, sellerId, transactionId, true))
            return false;

        return UpdateTransactionState(transactionId, TransactionStatus.Confirmed);
    }

Will give a quick fix create method: "Create method 'MyMethod(T2, UUID)'". When implementing the quick fix, it will give the following method:

    private void MyMethod(T2 seller, UUID sellerId) {
    }

when instead it should be:

    private <T2> void MyMethod(T2 seller, UUID sellerId) {
    }

Here is an example file you requested.

package com.myprojects.tipsytomatopizzeria;

import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;


/**
 * The TransactionLedger should be involved with all orders and thus transactions. It exposes a set of methods for working with transactions and can be trusted to be the single source of truth regarding them.
 */
//TODO: make this class thread safe...
public class TransactionLedger 
{
    //#region private fields
    private static TransactionLedger _transactionLedgerInstance;
    private ConcurrentMap<UUID, Object> _validTransactionPartners;
    private ConcurrentMap<UUID, Transaction> _transactions;
    private final long _transactionExpiryTime;
    //#endregion

    //#region private constructor
    private TransactionLedger()
    {
        this(300);
    }

    private TransactionLedger(long transactionExpiryTime)
    {
        _validTransactionPartners = new ConcurrentHashMap<UUID, Object>();
        _transactions = new ConcurrentHashMap<UUID, Transaction>();
        _transactionExpiryTime = transactionExpiryTime;
    }
    //#endregion

    //#region public static factory constructor
    /**
     * Instance
     * @return Instance of TransactionLedger. Initialize TransactionLedger with a default expiration time of 300 seconds. Note, TransactionLedger 
     * can only be intialized once as it is a singleton.
     */
    public static TransactionLedger Instance() 
    {
        if (_transactionLedgerInstance == null)
            _transactionLedgerInstance = new TransactionLedger();

        return _transactionLedgerInstance;
    }

    /**
     * Instance
     * @param transactionExpiryTime Expiration time for a transaction. If the seller does not confirm a newly opened transaction within this time period, it will expire.
     * @return Instance of TransactionLedger. TransactionLedger can only be intialized once as it is a singleton.
     */
    public static TransactionLedger Instance(long transactionExpiryTime) 
    {
        if (_transactionLedgerInstance == null)
            _transactionLedgerInstance = new TransactionLedger(transactionExpiryTime);

        return _transactionLedgerInstance;
    }
    //#endregion

    //#region public methods
    public Object GetValidPartnerInfo(UUID partnerId)
    {
        return _validTransactionPartners.get(partnerId);
    }

    public <T1, T2> UUID StartTransaction(T1 buyer, UUID buyerId, T2 seller, Order order)
    {
        if (!IsRegistered(buyer, buyerId))
            return null;

        UUID sellerId = GetId(seller);
        if (sellerId == null)
            return null;
        
        return InitiateTransaction(buyerId, sellerId, order);
    }

    public <T1, T2> Boolean ConfirmTransaction(T2 seller, UUID sellerId, UUID transactionId)
    {
        if (!VerifyTransactionPartner(seller, sellerId, transactionId, true))
            return false;

        return UpdateTransactionState(transactionId, TransactionStatus.Confirmed);
    }

    public <T1, T2> Boolean CancelTransaction(T1 buyer, UUID buyerId, UUID transactionId)
    {
        if (!VerifyTransactionPartner(buyer, buyerId, transactionId, false))
            return false;

        return UpdateTransactionState(transactionId, TransactionStatus.Cancelled);
    }

    public <T1, T2> Boolean RejectTransaction(T1 seller, UUID sellerId, UUID transactionId)
    {
        if (!VerifyTransactionPartner(seller, sellerId, transactionId, true))
            return false;

        return UpdateTransactionState(transactionId, TransactionStatus.Rejected);
    }

    //TODO: Should not be able to get to the buyerId or sellerId...
    public <T> TransactionInfo GetTransaction(T transactionPartner, UUID transactionPartnerId, UUID transactionId)
    {
        if (!(VerifyTransactionPartner(transactionPartner, transactionPartnerId, transactionId, true) || 
            VerifyTransactionPartner(transactionPartner, transactionPartnerId, transactionId, false)))
            return null;

        Transaction transaction = _transactions.get(transactionId);
        return new TransactionInfo(
            transaction.buyer(this),
            transaction.seller(this), 
            transaction.order(), 
            transaction.transactionId(), 
            transaction.status(), 
            transaction.createdOn());
    }

    public <T1, T2> Boolean VerifyTransaction(T1 buyer, T2 seller, UUID transactionId)
    {
        return VerifyTransactionPartner(buyer, transactionId, false) && VerifyTransactionPartner(seller, transactionId, true);
    }
    //#endregion

    // #region private methods
    private <T> boolean IsRegistered(T transactionPartner, UUID transactionPartnerId) 
    {
        if (transactionPartner == null || transactionPartnerId == null)
            return false;

        Object participant = _validTransactionPartners.get(transactionPartnerId);
        if (participant != null && participant.getClass() == transactionPartner.getClass() && participant.equals(transactionPartner))
            return true;
        else
            return false;
    }

    private <T> UUID GetId(T transactionPartner)
    {
        if (transactionPartner == null)
            return null;
        
        Optional<UUID> transactionPartnerId = _validTransactionPartners.entrySet().stream().filter(tp -> tp.getValue() == transactionPartner).map(tp -> tp.getKey()).findFirst();
        return transactionPartnerId.orElse(null);
    }

    private UUID InitiateTransaction(UUID buyerId, UUID sellerId, Order order) 
    {
        if (buyerId == null || sellerId == null || order == null)
            return null;

        UUID transactionId = UUID.randomUUID();
        order.InitializeTransactionId(transactionId);
        Transaction transaction = Transaction.Create(buyerId, sellerId, transactionId, order, System.currentTimeMillis(), _transactionExpiryTime);

        if (transaction == null)
            return null;
        
        _transactions.put(transactionId, transaction);

        return transactionId;
    }

    private Boolean UpdateTransactionState(UUID transactionId, TransactionStatus newStatus) 
    {
        Transaction transaction = _transactions.get(transactionId);
        if (transaction == null)
            return false;
        
        return transaction.UpdateStatus(newStatus);
    }

    private <T1> boolean VerifyTransactionPartner(T1 buyer, UUID transactionId, boolean isSeller) 
    {
        return VerifyTransactionPartner(buyer, GetId(buyer), transactionId, isSeller);
    }

    private <T2> Boolean VerifyTransactionPartner(T2 transactionPartner, UUID transactionPartnerId, UUID transactionId, boolean isSeller) 
    {
        if (transactionPartner == null || transactionPartnerId == null || transactionId == null)
            return false;

        if (!IsRegistered(transactionPartner, transactionPartnerId))
            return false;

        Transaction transaction = _transactions.get(transactionId);
        // return isSeller ? transaction.sellerId() == transactionPartnerId : transaction.buyerId() == transactionPartnerId;
        return isSeller ? transaction.seller(this) == transactionPartner : transaction.buyer(this) == transactionPartner;
    }
    //#endregion
}

[fbricon]

I can reproduce the issue with Eclipse, there's an existing open bug for that: https://bugs.eclipse.org/bugs/show_bug.cgi?id=539067

[fbricon]

Can no longer reproduce. This must have been fixed a while ago.