Repository: TypeScript
Issue: Ability to decorate abstract member function
Labels: Suggestion,Awaiting More Feedback

<!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨

Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker.

Please help us by doing the following steps before logging an issue:
  * Search: https://github.com/Microsoft/TypeScript/search?type=Issues
  * Read the FAQ, especially the "Common Feature Requests" section: https://github.com/Microsoft/TypeScript/wiki/FAQ

-->

## Search Terms

I search "decorate abstract member" in the issues list, and #20887 has memtioned this issue but closed.

## Suggestion

<!-- A summary of what you'd like to see added or changed -->
Ability to decorate abstract function and its params.

## Use Cases
To implement a [retrofit](https://square.github.io/retrofit/)-like http request library with Typescript.  Examples from retrofit website: 
```java
public interface GitHubService {
  @GET("users/{user}/repos")
  Call<List<Repo>> listRepos(@Path("user") String user);
}
```
When translate it into Typescript, we need to decorate an abstract class since interface will be erased after compilation. But,
```typescript
@MyAPI() // Okay, abstract class is decoratable
abstract class GitHubService {
  @GET("users/{user}/repos")  // ERROR: Cannot decorate an abstract class member
  abstract Call<List<Repo>> listRepos(@Path("user") user: string);  // ERROR 
}
```
<!--
What do you want to use this for?
What shortcomings exist with current approaches?
-->
To workaround such limitation, we cannot use abstract class, so it turns out to be
```typescript
@MyAPI() // Okay, abstract class is decoratable
class GitHubService {
  @GET("users/{user}/repos") 
  Call<List<Repo>> listRepos(@Path("user") user: user) {  
    throw new Error('unimplemented');
  } 
}
```
This is obviousely not elegant.

I think such ability can be implemented without breaks existing valid code. 
Decorator function can determin wheter it's decorating an abstract member by check if value of  property descriptor is undefined.

```typescript
function ClassMemberDecorator(prototype: {}, name: string, pd: PropertyDescriptor) {
  if (typeof pd.value === 'undefined') { // we're decorating abstract member
  }
}

function ClassMemberParamDecorator(prototype: {}, name: string, index: number) {
   if (typeof prototype[name] === 'undefiend') { // we're decorating abstract member param
   }
}
```
Since when targetting ES3, `PropertyDescriptor.value` is always undefined, this feature shall only be supported when targetting ES5-onward. 


## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).