For sure, this is a problem on android. Not sure about apple.

See example output:

## ContinuousPerformance

*removed* interface: `ContinuousPerformance`

*removed* method: `void setIsActiveTokenGenerator(IsActiveTokenGenerator)`

## ContinuousPerforming

*new* interface: `ContinuousPerforming`

*new* method: `void setIsActiveTokenGenerator(IsActiveTokenGenerator)`

apidiff has no way of knowing that ContinuousPerformance was renamed to ContinuousPerforming. The only context it has is that ContinuousPerformance was removed and ContinuousPerforming was added. Ideally, the output should show that ContinuousPerformance was modified to ContinuousPerforming.

One possibility is to allow the user to specify renames on the command line.

Consider the following recent output:

## MDMSchedulerActivityStateIdle
## MDMSchedulerActivityState
## MDMSchedulerDelegate
## MDMConsoleLoggingTracer
## MDMRuntimeFeatures
## MDMPerforming
## MDMComposablePerforming
## MDMTransaction
## MDMScheduler
## MDMTransactionEmitting
## MDMTracing
## MDMRuntimeActivityState
## MDMRuntimeDelegate
## MDMSchedulerActivityStateActive
## MDMRuntime

These groups should be alphabetized.

material-components/material-components-ios#6027

This is a pretty critical omission from the generated release notes unfortunately.

https://github.com/mattstevens/objc-diff was able to pick up deprecation attributes, so we may want to look how they did so.

For example:

public class foo.bar.Foo<T extends baz.qux.Bar>

Where signature should be foo.bar.Foo, but existing (\S+) captures foo.bar.Foo<T

Output

new annotation: @BooleanRemixMethod

Instead of

new class: BooleanRemixMethod

MDC release 84.0.0 produced a weird snippet and was called out in this comment thread.

I suspect it is because the commit was not amended properly to use the PR's description. This is not something the API diff too can fix. Unless we want it to ignore the Commit message and use the resolved PR description?

For example:

public static <T> void bind(T);

Should have:
signature: <T> bind(T)
short_description: <T> void bind(T)

And:

public static <T extends Bar> void bind(T);

Should have:
signature: <T extends Bar> bind(T)
short_description: <T extends Bar> void bind(T)

Right now, short_description is parsed correctly, but only because object_type = '.+?\s+' matches <T> void, which is actually a bug. object_type should match void instead.

Right now, signature is not parsed correctly. It is parsed as bind(T) when it needs to have the typed parameter as well to distinguish from the two cases above which are both legal in the same class.

E..g. src/MaterialMotionRuntime.h

From alexisgallagher:

Does it auto generate an indication when the API change breaks compatibility for code that depended on the old API?

Things we need to do to make this happen:

• Add a new API to ApiChange for isBreaking().
• If an ApiChange is a breaking change, output additional markdown highlighting this fact.

It may make sense to aggregate breaking API changes near the top of the output as well.

Open question.

See https://github.com/material-motion/indefinite-observable-android/releases/tag/2.0.0

Right now this tool looks for an android library AAR output at $library/build/outputs/aar/$library-debug.aar. Java libraries output a JAR file at $library/build/libs/$library.jar. If we look there as well, this tool would work as-is for Java libraries.

On Android, building a newly checked out repo could takes a long time. And apidiff does this twice.

When running scripts/release apidiff while doing a Material-Components-iOS release the output is

Changelog=/var/folders/5g/3j6wbymd03jbv54v218wgbvw00jg1r/T/tmp.E0SqXEWc/changelog
Errors=/var/folders/5g/3j6wbymd03jbv54v218wgbvw00jg1r/T/tmp.E0SqXEWc/errlog
Diffing Chips (components/Chips/src)...

But nothing happens.

This is with sourcekitten 0.23.2.

For example:

public abstract java.lang.String key();

Should output:

*new* abstract method: `String key()`

Right now we git clone for both old-ref and new-ref.
Consider git checkout instead.

This will allow us to declare local refs for old-ref and new-ref, rather than using pushed refs like release-candidate.

Objective-C frameworks that have dependencies don't work with apidiff due to the inability to resolve header imports. If these imports are resolved, apidiff ends up generating API diffs for both the current library and all of its dependencies (certainly not ideal).

Ideally apidiff would check out the relevant dependencies at the relevant versions and then filter apidiff results to only those found within the current library.

This would simplify integration with other tooling.

I 'm thinking of a --json flag that would change the output from formatted markdown to JSON.

Strange changes when category implementations are shifted down in a file.

Repro case

Before

@interface MDCFlexibleHeaderView: UIView
@property(nonatomic, strong) UIView *someView;
@end

@interface MDCFlexibleHeaderView ()

#pragma mark Accessing the header's views

/** Deprecated. Please register views directly to the flexible header. */
@property(nonatomic, strong, nonnull) UIView *contentView;

@end

After

@interface MDCFlexibleHeaderView: UIView
@property(nonatomic, strong) UIView *someView;
@property(nonatomic, strong) UIView *anotherView;
@end

@interface MDCFlexibleHeaderView ()

#pragma mark Accessing the header's views

/** Deprecated. Please register views directly to the flexible header. */
@property(nonatomic, strong, nonnull) UIView *contentView;

@end

Partial generated output

None of the following is expected to be generated:

#### MDCFlexibleHeaderView()

 *new* category: `MDCFlexibleHeaderView()`

 *removed* category: `MDCFlexibleHeaderView()`

 *modified* property: `contentView` in `MDCFlexibleHeaderView()`

 | Type of change: | parent.usr |
|---|---|
| From: | `c:objc(ext)[email protected]@14009` |
| To: | `c:objc(ext)[email protected]@14344` |

Current output is:

new static final field: FOO_BAR

Proposed output is:

new constant: FOO_BAR

Implementation would modify kind_description like for #5

Ideal outcome of this task is apidiff generating an API diff artifact on each commit to develop for a repo, such that when a release is cut we can simply grab the latest apidiff artifact from Travis.

Some other cool features this would enable:

• CI notifications for when the public API changes.