[Polly] Added arcanist linters and cleaned errors and warnings

[jdoerfert]

Summary

Arcanist (arc) will now always run linters before uploading any new
commit to Phabricator. All errors/warnings (or their absence) will be
shown in the web interface together with a explanation by the commiter
(arcanist will ask the commiter if the build was not clean).

The linters include:
  - clang-format
  - spelling check
  - permissions check (aka. chmod)
  - filename check
  - merge conflict marker check
Note, that their scope is sometimes limited (see .arclint for
details).

This commit also fixes all errors and warnings these linters reported,
namely:
  - spelling mistakes and typos
  - executable permissions for various text files

[sebpop]

LGTM.

What happens if a patch with lint errors gets committed the old way without being submitted through arc?
Will that cause errors in the next patch submitted with arc?

[jdoerfert]

It might cause errors/warnings in the next commit, yes. It depends on the kind of linter I think. Afaik. not all run on unchanged files, clang-format will run though, so the next commiter might want to fix the repo with a commit first.

I will use arcanist from now on anyway (unless I get resistance from you guys).

[jdoerfert]

Closed by commit rL215871 (authored by @jdoerfert).

polly/trunk/.arcconfig

 {
   "project_id" : "polly",
-  "conduit_uri" : "http://reviews.llvm.org/"
+  "conduit_uri" : "http://reviews.llvm.org/",
+  "linter.scriptandregex.script": "sh -c './utils/check_format.sh \"$0\" 2> /dev/null || true'",
+  "linter.scriptandregex.regex": "/^(OK:(?P<ignore>.+)|Error:) (?P<message>.+)$/m"
 }

polly/trunk/.arclint

+{
+  "linters": {
+    "format": {
+      "include": "(include/polly/.+\\.h$|lib/.+\\.cpp$)",
+      "exclude": "(lib/JSON/.*)",
+      "type": "script-and-regex"
+    },
+    "chmod": {
+      "type": "chmod"
+    },
+    "filename": {
+      "exclude": "(www/experiments/.+|.*\\.jscop.*)",
+      "type": "filename"
+    },
+    "merge-conflict": {
+      "type": "merge-conflict"
+    },
+    "spelling": {
+      "exclude": "(configure|autoconf/.*)",
+      "type": "spelling"
+    }
+  }
+}

polly/trunk/CMakeLists.txt

 # Check if this is a in tree build.
 if (NOT DEFINED LLVM_MAIN_SRC_DIR)
   project(Polly)
   cmake_minimum_required(VERSION 2.8)
 
   # Where is LLVM installed?
   set(LLVM_INSTALL_ROOT "" CACHE PATH "Root of LLVM install.")
   # Check if the LLVM_INSTALL_ROOT valid.
   if( NOT EXISTS ${LLVM_INSTALL_ROOT}/include/llvm )
     message(FATAL_ERROR "LLVM_INSTALL_ROOT (${LLVM_INSTALL_ROOT}) is not a valid LLVM installation.")
   endif(NOT EXISTS ${LLVM_INSTALL_ROOT}/include/llvm)
   #FileCheck is not install by default, warn the user to Copy FileCheck
   if( NOT EXISTS ${LLVM_INSTALL_ROOT}/bin/FileCheck
       OR NOT EXISTS ${LLVM_INSTALL_ROOT}/bin/not)
-    message(WARNING "FileCheck or not are requred by running regress tests, "
+    message(WARNING "FileCheck or not are required by running regress tests, "
                     "but they are not installed! Please copy it to "
                     "${LLVM_INSTALL_ROOT}/bin.")
   endif(NOT EXISTS ${LLVM_INSTALL_ROOT}/bin/FileCheck
         OR NOT EXISTS ${LLVM_INSTALL_ROOT}/bin/not)
   # Add the llvm header path.
   include_directories(${LLVM_INSTALL_ROOT}/include/)
 
   # Get the system librarys that will link into LLVM.

polly/trunk/autoconf/configure.ac

 dnl **************************************************************************
 dnl * Initialize
 dnl **************************************************************************
 AC_INIT([Polly],[0.01],[[e-mail]])
 
 dnl Identify where LLVM source tree is
 LLVM_SRC_ROOT="`(cd $srcdir/../..; pwd)`"
 LLVM_OBJ_ROOT="`(cd ../..; pwd)`"
 
 dnl Tell autoconf that this is an LLVM project being configured
 dnl This provides the --with-llvmsrc and --with-llvmobj options
 LLVM_CONFIG_PROJECT($LLVM_SRC_ROOT,$LLVM_OBJ_ROOT)
 
-dnl Tell autoconf that the auxilliary files are actually located in
+dnl Tell autoconf that the auxiliary files are actually located in
 dnl the LLVM autoconf directory, not here.
 AC_CONFIG_AUX_DIR($LLVM_SRC/autoconf)
 
 dnl Indicate that we require autoconf 2.59 or later. Ths is needed because we
 dnl use some autoconf macros only available in 2.59.
 AC_PREREQ(2.59)
 
 dnl Verify that the source directory is valid

polly/trunk/autoconf/configure.bak

 dnl **************************************************************************
 dnl * Initialize
 dnl **************************************************************************
 AC_INIT([Polly],[0.01],[[e-mail] [e-mail] [e-mail]])
 
 dnl Identify where LLVM source tree is
 LLVM_SRC_ROOT="../.."
 LLVM_OBJ_ROOT="../.."
-dnl Tell autoconf that the auxilliary files are actually located in
+dnl Tell autoconf that the auxiliary files are actually located in
 dnl the LLVM autoconf directory, not here.
 AC_CONFIG_AUX_DIR($LLVM_SRC_ROOT/autoconf)
 
 dnl Tell autoconf that this is an LLVM project being configured
 dnl This provides the --with-llvmsrc and --with-llvmobj options
 LLVM_CONFIG_PROJECT($LLVM_SRC_ROOT,$LLVM_OBJ_ROOT)
 
 dnl Verify that the source directory is valid

polly/trunk/lib/Analysis/ScopInfo.cpp

 using namespace llvm;
 using namespace polly;
 
 #define DEBUG_TYPE "polly-scops"
 
 STATISTIC(ScopFound, "Number of valid Scops");
 STATISTIC(RichScopFound, "Number of Scops containing a loop");
 
-// Multiplicative reductions can be disabled seperately as these kind of
+// Multiplicative reductions can be disabled separately as these kind of
 // operations can overflow easily. Additive reductions and bit operations
 // are in contrast pretty stable.
 static cl::opt<bool> DisableMultiplicativeReductions(
     "polly-disable-multiplicative-reductions",
     cl::desc("Disable multiplicative reductions"), cl::Hidden, cl::ZeroOrMore,
     cl::init(false), cl::cat(PollyCategory));
 
 /// Translate a 'const SCEV *' expression in an isl_pw_aff.

polly/trunk/lib/JSON/include/json/value.h

public:
       char *keys_[itemPerLink];
       ValueInternalLink *previous_;
       ValueInternalLink *next_;
    };
 
 
    /** \brief A linked page based hash-table implementation used internally by Value.
     * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked
-    * list in each bucket to handle collision. There is an addional twist in that
+    * list in each bucket to handle collision. There is an additional twist in that
     * each node of the collision linked list is a page containing a fixed amount of
     * value. This provides a better compromise between memory usage and speed.
     * 
     * Each bucket is made up of a chained list of ValueInternalLink. The last
     * link of a given bucket can be found in the 'previous_' field of the following bucket.
     * The last link of the last bucket is stored in tailLink_ as it has no following bucket.
     * Only the last link of a bucket may contains 'available' item. The last link always
     * contains at least one element unless is it the bucket one very first link.

polly/trunk/lib/JSON/include/json/writer.h

public:
       virtual ~Writer();
 
       virtual std::string write( const Value &root ) = 0;
    };
 
    /** \brief Outputs a Value in <a HREF="http://www.json.org">JSON</a> format without formatting (not human friendly).
     *
     * The JSON document is written in a single line. It is not intended for 'human' consumption,
-    * but may be usefull to support feature such as RPC where bandwith is limited.
+    * but may be useful to support feature such as RPC where bandwidth is limited.
     * \sa Reader, Value
     */
    class JSON_API FastWriter : public Writer
    {
    public:
       FastWriter();
       virtual ~FastWriter(){}
 

polly/trunk/lib/Transform/CodePreparation.cpp

 // strategy different PHI nodes are translated:
 //
 // - indvars based code generation:
 //
 // The indvars based code generation requires explicit canonical induction
 // variables. Such variables are generated before scop detection and
 // also before the code preparation pass. All PHI nodes that are not canonical
 // induction variables are not supported by the indvars based code generation
-// and are consequently translated into explict memory accesses.
+// and are consequently translated into explicit memory accesses.
 //
 // - scev based code generation:
 //
 // The scev based code generation can code generate all PHI nodes that do not
 // reference parameters within the scop. As the code preparation pass is run
 // before scop detection, we can not check this condition, because without
 // a detected scop, we do not know SCEVUnknowns that appear in the SCEV of
 // a PHI node may later be within or outside of the SCoP. Hence, we follow a

polly/trunk/test/Cloog/ambigous_schedule.ll

 
 ; CHECK: for (c2=0;c2<=99;c2++) {
 ; CHECK:   for (c3=0;c3<=99;c3++) {
 ; CHECK:     Stmt_for_body3(c2,c3);
 ; CHECK:     Stmt_for_body18(c3,c2);
 ; CHECK:   }
 ; CHECK: }
 
-; This check makes sure CLooG stops splitting for ambigious schedules as
+; This check makes sure CLooG stops splitting for ambiguous schedules as
 ; they may be generated by the isl/PoCC/Pluto schedule optimizers.
 ;
 ; Previously we created such code:
 ;
 ; for (c2=0;c2<=99;c2++) {
 ;   for (c3=0;c3<=99;c3++) {
 ;     if (c2 == c3) {
 ;       Stmt_for_body3(c2,c2);

polly/trunk/utils/check_format.sh

 #!/bin/bash
 
 CLANG_FORMAT=${CLANG_FORMAT}
 
 if [ "${CLANG_FORMAT}x" = "x" ]; then
   CLANG_FORMAT=`which clang-format`
   if [ "${CLANG_FORMAT}x" = "x" ]; then
      echo "Error: cannot find clang-format in your path"
      exit 1
   fi
 fi
 
 OK=0
 
 for ARG in "$@"
   do
-    ${CLANG_FORMAT} $ARG | diff -u $ARG -
+    ${CLANG_FORMAT} -style=llvm $ARG | diff -u $ARG - >&2
 
     if [[ $? -eq 1 ]]; then
       OK=1
     fi
   done
 
 if [[ $OK -eq "1" ]]; then
   echo "Error: clang-format reported formatting differences"
   exit 1
 else
   echo "OK: clang-format reported no formatting differences"
   exit 0
 fi
 

polly/trunk/www/video-js/video.js

init: function(element, setOptions){
 
     // Allow an ID string or an element
     if (typeof element == 'string') {
       this.video = document.getElementById(element);
     } else {
       this.video = element;
     }
     // Store reference to player on the video element.
-    // So you can acess the player later: document.getElementById("video_id").player.play();
+    // So you can access the player later: document.getElementById("video_id").player.play();
     this.video.player = this;
     this.values = {}; // Cache video values.
     this.elements = {}; // Store refs to controls elements.
 
     // Default Options
     this.options = {
       autoplay: false,
       preload: true,
for (var i=0,j=children.length; i<j; i++) {
           this.canPlaySourceResult = true;
           return true;
         }
       }
     }
     this.canPlaySourceResult = false;
     return false;
   },
-  // Check if the extention is compatible, for when type won't work
+  // Check if the extension is compatible, for when type won't work
   canPlayExt: function(src){
     if (!src) { return ""; }
     var match = src.match(/\.([^\.]+)$/);
     if (match && match[1]) {
       var ext = match[1].toLowerCase();
       // Android canPlayType doesn't work
       if (VideoJS.isAndroid()) {
         if (ext == "mp4" || ext == "m4v") { return "maybe"; }
onCurrentTimeScrubberMouseDown: function(event, scrubber){
       this.videoWasPlaying = !this.paused();
       this.pause();
 
       _V_.blockTextSelection();
       this.setCurrentTimeWithScrubber(event);
       _V_.addListener(document, "mousemove", this.onCurrentTimeScrubberMouseMove.rEvtContext(this));
       _V_.addListener(document, "mouseup", this.onCurrentTimeScrubberMouseUp.rEvtContext(this));
     },
-    onCurrentTimeScrubberMouseMove: function(event){ // Removeable
+    onCurrentTimeScrubberMouseMove: function(event){ // Removable
       this.setCurrentTimeWithScrubber(event);
     },
-    onCurrentTimeScrubberMouseUp: function(event){ // Removeable
+    onCurrentTimeScrubberMouseUp: function(event){ // Removable
       _V_.unblockTextSelection();
       document.removeEventListener("mousemove", this.onCurrentTimeScrubberMouseMove, false);
       document.removeEventListener("mouseup", this.onCurrentTimeScrubberMouseUp, false);
       if (this.videoWasPlaying) {
         this.play();
         this.trackCurrentTime();
       }
     },
VideoJS.player.newBehavior("fullscreenToggle", function(element){
     onFullscreenToggleClick: function(event){
       if (!this.videoIsFullScreen) {
         this.enterFullScreen();
       } else {
         this.exitFullScreen();
       }
     },
 
-    fullscreenOnWindowResize: function(event){ // Removeable
+    fullscreenOnWindowResize: function(event){ // Removable
       this.positionControlBars();
     },
     // Create listener for esc key while in full screen mode
-    fullscreenOnEscKey: function(event){ // Removeable
+    fullscreenOnEscKey: function(event){ // Removable
       if (event.keyCode == 27) {
         this.exitFullScreen();
       }
     }
   }
 );
 /* Big Play Button Behaviors
 ================================================================================ */
Function.prototype.evtContext = function(obj){
   var method = this,
   temp = function(){
     var origContext = this;
     return method.call(obj, arguments[0], origContext);
   };
   return temp;
 };
 
-// Removeable Event listener with Context
+// Removable Event listener with Context
 // Replaces the original function with a version that has context
 // So it can be removed using the original function name.
 // In order to work, a version of the function must already exist in the player/prototype
 Function.prototype.rEvtContext = function(obj, funcParent){
   if (this.hasContext === true) { return this; }
   if (!funcParent) { funcParent = obj; }
   for (var attrname in funcParent) {
     if (funcParent[attrname] == this) {

 }
 
 
 // Expose to global
 window.VideoJS = window._V_ = VideoJS;
 
 // End self-executing function
 })(window);
 No newline at end of file