shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
197,988 Commits 1,712 Branches 298 Tags
Commit Graph

64 Commits

Author SHA1 Message Date
Daniel Jasper
acf67e3ecd clang-format: Improve nested block formatting. 
Before:
  functionA(functionB({
    int i;
    int j;
  }),
            aaaa, bbbb, cccc);

After:
  functionA(functionB({
              int i;
              int j;
            }),
            aaaa, bbbb, cccc);

llvm-svn: 234304
 2015-04-07 08:20:35 +00:00
Daniel Jasper
739ec534d2 clang-format: [JS] Understand object literals with only methods. 
Before:
  let theObject = {someMethodName() {
    doTheThing();
    doTheOtherThing();
  },
                   someOtherMethodName() {
                     doSomething();
                     doSomethingElse();
                   }};

After:
  let theObject = {
    someMethodName() {
      doTheThing();
      doTheOtherThing();
    },
    someOtherMethodName() {
      doSomething();
      doSomethingElse();
    }
  };

llvm-svn: 234091
 2015-04-04 07:56:55 +00:00
Daniel Jasper
f46dec86b6 clang-format: [JS] Support getters, setters and methods in object literals. 
llvm-svn: 233698
 2015-03-31 14:34:15 +00:00
Daniel Jasper
02c7bca5d1 clang-format: [JS] Fix comment formatting in goog.scopes. 
Before:
  goog.scope(function() {
  // test
  var x = 0;
  // test
  });

After:
  goog.scope(function() {
  // test
  var x = 0;
    // test
  });

llvm-svn: 233530
 2015-03-30 09:56:50 +00:00
Daniel Jasper
bc46b939e6 clang-format: [JS] support cast syntax and type arguments. 
Casts in TS syntax (foo = <type>bar;) should not be followed by
whitespace.

Patch by Martin Probst. Thank you.

llvm-svn: 232321
 2015-03-15 13:59:51 +00:00
Daniel Jasper
60948b12bb clang-format: [JS] more precisely detect enums. 
The current enum detection is overly aggressive. As NestingLevel only
applies per line (?) it classifies many if not most object literals as
enum declarations and adds superfluous line breaks into them. This
change narrows the heuristic by requiring an assignment just before the
open brace and requiring the line to start with an identifier.

Patch by Martin Probst. Thank you.

llvm-svn: 232320
 2015-03-15 13:55:54 +00:00
Daniel Jasper
a0ef4f36c8 clang-format: [js] Support template strings. 
Merge template strings (marked by backticks ``).
Do not format any contents of template strings.

Patch by Martin Probst. Thank you.

llvm-svn: 230011
 2015-02-20 13:47:38 +00:00
Daniel Jasper
fca735cd58 clang-format: [js] Support ES6 module exports. 
Patch by Martin Probst, thank you!

llvm-svn: 229865
 2015-02-19 16:14:18 +00:00
Daniel Jasper
354aa51587 clang-format: [js] Support ES6 module imports. 
Patch by Martin Probst.

llvm-svn: 229863
 2015-02-19 16:07:32 +00:00
Daniel Jasper
6fa9ec7885 clang-format: [js] Do not fall through for JS structural elements. 
Patch by Martin Probst. Thank you.

llvm-svn: 229862
 2015-02-19 16:03:16 +00:00
Daniel Jasper
3c42dba2dc clang-format: [JS] support AtScript style annotations for JS. 
Based on Java annotation support and style.

Patch by Martin Probst.

llvm-svn: 229703
 2015-02-18 17:17:15 +00:00
Daniel Jasper
8370908667 clang-format: [JS] Support classes. 
This adds support for JavaScript class definitions (again following
TypeScript & AtScript style). This only required support for
visibility modifiers in JS, everything else was already working.

Patch by Martin Probst, thank you.

llvm-svn: 229701
 2015-02-18 17:14:05 +00:00
Daniel Jasper
b10bdff337 clang-format: [JS] Support type annotations. 
This patch adds support for type annotations that follow TypeScript's,
Flow's, and AtScript's syntax style.

Patch by Martin Probst, thank you.
Review: http://reviews.llvm.org/D7721

llvm-svn: 229700
 2015-02-18 17:09:53 +00:00
Daniel Jasper
0580ff0ec6 clang-format: Fix incorrect calculation of token lenghts. 
This led, e.g. to break JavaScript regex literals too early.

llvm-svn: 224419
 2014-12-17 09:11:08 +00:00
Daniel Jasper
11a0ac66e1 clang-format: Revamp nested block formatting. 
This fixed llvm.org/PR21804 and hopefully a few other strange cases.

Before:
    if (blah_blah(whatever, whatever, [] {
      doo_dah();
      doo_dah();
    })) {
    }
    }

After:
    if (blah_blah(whatever, whatever, [] {
          doo_dah();
          doo_dah();
        })) {
    }
    }

llvm-svn: 224112
 2014-12-12 09:40:58 +00:00
Daniel Jasper
a4e55f4d1e clang-format: [JS] Don't put top-level dict literals on a single line. 
These are often used for enums which apparently are easier to read if
formatted with one element per line.

llvm-svn: 223367
 2014-12-04 16:07:17 +00:00
Daniel Jasper
41368e9e07 clang-format: [JS] Contract fewer functions to a single line. 
Before:
  var someVariable =
      function(x) { return x.zIsTooLongForOneLineWithTheDeclarationLine(); };

After:
  var someVariable = function(x) {
    return x.zIsTooLongForOneLineWithTheDeclarationLine();
  };

llvm-svn: 222893
 2014-11-27 15:37:42 +00:00
Daniel Jasper
4087432f8b clang-format: [JS] Try not to break in container literals. 
Before:
  var obj = {
    fooooooooo:
        function(x) { return x.zIsTooLongForOneLineWithTheDeclarationLine(); }
  };

After:
  var obj = {
    fooooooooo: function(x) {
      return x.zIsTooLongForOneLineWithTheDeclarationLine();
    }
  };

llvm-svn: 222892
 2014-11-27 15:24:48 +00:00
Daniel Jasper
7912123893 clang-format: [JS] new and delete are valid function names. 
Before:
  someObject.new ();
  someObject.delete ();

After:
  someObject.new();
  someObject.delete();

llvm-svn: 222890
 2014-11-27 14:55:17 +00:00
Daniel Jasper
53c38f4e79 clang-format: [JS] Make Closure module detection more narrow. 
Before:
  var MyLongClassName = goog.module.get('my.long.module.name.followedBy.MyLongClassName');

After:
  var MyLongClassName =
      goog.module.get('my.long.module.name.followedBy.MyLongClassName');

llvm-svn: 222888
 2014-11-27 14:46:03 +00:00
Daniel Jasper
616de864da clang-format: [JS] Support Closure's module statements. 
These are like import statements and should not be line-wrapped. Minor
restructuring of the handling of other import statements.

llvm-svn: 222637
 2014-11-23 16:46:28 +00:00
Daniel Jasper
e551bb70a3 Revert "clang-format: [js] Updates to Google's JavaScript style." 
This reverts commit eefd2eaad43c5c2b17953ae7ed1e72b28e696f7b.

Apparently, this change was a bit premature.

llvm-svn: 221365
 2014-11-05 17:22:31 +00:00
Daniel Jasper
f739b0dbfa clang-format: [js] Updates to Google's JavaScript style. 
The style guide is changing..

llvm-svn: 220977
 2014-10-31 17:50:40 +00:00
Daniel Jasper
49a9a2833b clang-format: [JS] Support more regex literals. 
Previously a regex-literal containing "/*" would through clang-format
off, e.g.:
  var regex = /\/*$/;

Would lead to none of the following code to be formatted.

llvm-svn: 220860
 2014-10-29 16:51:38 +00:00
Daniel Jasper
67f8ad258f clang-format: [JS] Support AllowShortFunctionsOnASingleLine. 
Specifically, this also counts for stuff like (with style "inline"):
  var x = function() {
    return 1;
  };

llvm-svn: 218689
 2014-09-30 17:57:06 +00:00
Daniel Jasper
1779d438bc clang-format: [JS] Improve formatting of function literals in chains 
Before:
  getSomeLongPromise(.....)
      .then(
           function(value) {
             body();
             body();
           })
      .thenCatch(function(error) {
    body();
    body();
  });

After:
  getSomeLongPromise(.....)
      .then(function(value) {
        body();
        body();
      })
      .thenCatch(function(error) {
        body();
        body();
      });

llvm-svn: 218595
 2014-09-29 07:54:54 +00:00
Daniel Jasper
3549ea1a73 clang-format: [JS] add space before operator 'in'. 
Before:
  return ('aaa')in bbbb;

After:
  return ('aaa') in bbbb;

llvm-svn: 218119
 2014-09-19 10:48:15 +00:00
Daniel Jasper
23376259c0 clang-format: [JS] Support regex literals with trailing escaped slash. 
Before:
  var regex = / a\//; int i;

After:
  var regex = /a\//;
  int i;

This required pushing the Lexer into its wrapper class and generating a
new one in this specific case. Otherwise, the sequence get lexed as a
//-comment. This is hacky, but I don't know a better way (short of
supporting regex literals in the Lexer).

Pushing the Lexer down seems to make all the call sites simpler.

llvm-svn: 217444
 2014-09-09 14:37:39 +00:00
Daniel Jasper
90ebc98e3d clang-format: [JS] Format embedded function literals more efficently. 
Before:
  return {
    a: a,
    link:
        function() {
          f();  //
        },
    link:
        function() {
          f();  //
        }
  };

After:
  return {
    a: a,
    link: function() {
      f();  //
    },
    link: function() {
      f();  //
    }
  };

llvm-svn: 217238
 2014-09-05 09:27:38 +00:00
Daniel Jasper
3a038de3c8 clang-format: [JS] JavaScript does not have the */&/&& madness. 
Before:
  e&& e.SomeFunction();

After:
  e && e.SomeFunction();

Yeah, this might be useful for C++, too, but it is not such a frequent
pattern there (plus the fix is much harder).

llvm-svn: 217237
 2014-09-05 08:53:45 +00:00
Daniel Jasper
3f69ba1075 clang-format: [JS] Better support for empty function literals. 
Before:
  SomeFunction(function(){});

After:
  SomeFunction(function() {});

llvm-svn: 217236
 2014-09-05 08:42:27 +00:00
Daniel Jasper
97bfb7b1ba clang-format: [JS] Fix indentation in dict literals. 
Before:
  return {
    'finish':
        //
        a
        };

After:
  return {
    'finish':
        //
        a
  };

llvm-svn: 217235
 2014-09-05 08:29:31 +00:00
Daniel Jasper
4db69bd542 clang-format: [JS] Support alternative operator names as identifiers. 
Before:
  not. and . or . not_eq = 1;

After:
  not.and.or.not_eq = 1;

llvm-svn: 217179
 2014-09-04 18:23:42 +00:00
Daniel Jasper
8f2e94c8ab clang-format: [JS] Supprot "catch" as function name. 
Before:
  someObject.catch ();

After:
  someObject.catch();

llvm-svn: 217158
 2014-09-04 15:03:34 +00:00
Daniel Jasper
94e11d02d8 clang-format: [JS] Support comments in dict literals. 
Before:
  var stuff = {
    // comment for update
    update : false,
             // comment for update
    modules : false,
              // comment for update
    tasks : false
  };

After:
  var stuff = {
    // comment for update
    update : false,
    // comment for update
    modules : false,
    // comment for update
    tasks : false
  };

llvm-svn: 217157
 2014-09-04 14:58:30 +00:00
Daniel Jasper
ad9eb0d79d clang-format: [JS] support free-standing functions again. 
This worked initially but was broken by r210887.

Before:
  function outer1(a, b) {
    function inner1(a, b) { return a; } inner1(a, b);
  } function outer2(a, b) { function inner2(a, b) { return a; } inner2(a, b); }

After:
  function outer1(a, b) {
    function inner1(a, b) { return a; }
    inner1(a, b);
  }
  function outer2(a, b) {
    function inner2(a, b) { return a; }
    inner2(a, b);
  }

Thanks to Adam Strzelecki for working on this.

llvm-svn: 212038
 2014-06-30 13:24:54 +00:00
Daniel Jasper
5217a8b84f clang-format: [JS] Understand named function literals. 
Before:
  return {a: function SomeFunction(){// ...
                                     return 1;
  }
  }
  ;

After:
  return {
    a: function SomeFunction() {
      // ...
      return 1;
    }
  };

llvm-svn: 210887
 2014-06-13 07:02:04 +00:00
Daniel Jasper
17062ff550 clang-format: [JS] Treat dict literals similar to objc method exprs. 
Before:
  return {
    link:
        function() {
          f();  //
        }
        };
  return {
    a: a,
    link: function() {
      f();  //
    }
  }

After:
  return {
    link: function() {
      f();  //
    }
  };
  return {
    a: a,
    link: function() {
      f();  //
    }
  };

llvm-svn: 210537
 2014-06-10 14:44:02 +00:00
Daniel Jasper
58cb2edd69 clang-format: Fix incorrect indentation. 
Before (JavaScript example, but can extend to other languages):
  return {
    a: 'E',
    b: function() {
      return function() {
      f();  // This is wrong.
      };
    }
  };

After:
  return {
    a: 'E',
    b: function() {
      return function() {
        f();  // This is better.
      };
    }
  };

llvm-svn: 210334
 2014-06-06 13:49:04 +00:00
Daniel Jasper
114a2bc9d2 clang-format: Refactor indentation behavior for multiple nested blocks. 
This fixes a few oddities when formatting multiple nested JavaScript
blocks, e.g.:

Before:
  promise.then(
      function success() {
        doFoo();
        doBar();
      },
      [], function error() {
        doFoo();
        doBaz();
      });
  promise.then([],
               function success() {
                 doFoo();
                 doBar();
               },
               function error() {
    doFoo();
    doBaz();
  });

After:
  promise.then(
      function success() {
        doFoo();
        doBar();
      },
      [],
      function error() {
        doFoo();
        doBaz();
      });
  promise.then([],
               function success() {
                 doFoo();
                 doBar();
               },
               function error() {
                 doFoo();
                 doBaz();
               });

llvm-svn: 210097
 2014-06-03 12:02:45 +00:00
Daniel Jasper
49802ef93b clang-format: [JS] Understand line breaks in concatenated strings. 
Before:
  var literal = 'hello ' + 'world';

After:
  var literal = 'hello ' +
                'world';

There is no reason to concatenated two string literals with a '+' unless
the line break is intended.

llvm-svn: 209413
 2014-05-22 09:10:04 +00:00
Daniel Jasper
5f3ea477cf clang-format: Correctly calculate line lenghts for nest blocks. 
If simple (one-statement) blocks can be inlined, the length needs to be
calculated correctly.

Before (in JavaScript but this also affects lambdas, etc.):
  var x = {
    valueOf: function() { return 1; }
  };

After:
  var x = {valueOf: function() { return 1; }};

llvm-svn: 209410
 2014-05-22 08:36:53 +00:00
Daniel Jasper
2a958321c8 clang-format: Fix corner case working around one-per-line dict literals. 
Before:
  var object_literal_with_long_name = {
    a: 'aaaaaaaaaaaaaaaaaa', b: 'bbbbbbbbbbbbbbbbbb'
  };

After:
  var object_literal_with_long_name = {
    a: 'aaaaaaaaaaaaaaaaaa',
    b: 'bbbbbbbbbbbbbbbbbb'
  };

llvm-svn: 209296
 2014-05-21 13:26:58 +00:00
Daniel Jasper
b16b969d7c clang-format: [JS] Support different function literal style. 
Before:
  goog.array.forEach(array, function() {
                              doSomething();
                              doSomething();
                            },
                     this);

After:
  goog.array.forEach(array, function() {
    doSomething();
    doSomething();
  }, this);

llvm-svn: 209291
 2014-05-21 12:51:23 +00:00
Daniel Jasper
069e5f4858 clang-format: [JS] Understand top-level function literals properly. 
llvm-svn: 209205
 2014-05-20 11:14:57 +00:00
Daniel Jasper
0dd5291e69 clang-format: [JS] Support ES6 destructuring assignments. 
Before:
  var[a, b, c] = [1, 2, 3];

After:
  var [a, b, c] = [1, 2, 3];

llvm-svn: 209113
 2014-05-19 07:37:07 +00:00
Daniel Jasper
78214397a3 clang-format: [JS] Support for EC6 arrow functions. 
Before:
  var b = a.map((x) = > x + 1);

After:
  var b = a.map((x) => x + 1);

llvm-svn: 209112
 2014-05-19 07:27:02 +00:00
Daniel Jasper
fb4333b093 clang-format: [JS] Basic support for escape sequences in regex literals. 
Before:
  var regex = /\\/ g; // This isn't even recognized as regex.

After:
  var regex = /\\/g; // It now is.

llvm-svn: 208539
 2014-05-12 11:29:50 +00:00
Daniel Jasper
8951908218 clang-format: [JS] Fix spacing in dict literals. 
Before:
  someVariable = {'a':[{}]};

After:
  someVariable = {'a': [{}]};

llvm-svn: 208403
 2014-05-09 10:26:08 +00:00
Daniel Jasper
04a71a45ff clang-format: Initial support for try-catch. 
Most of this patch was created by Alexander Rojas in
http://reviews.llvm.org/D2555
Thank you!

Synced and addressed review comments.

llvm-svn: 208302
 2014-05-08 11:58:24 +00:00