Merge branch 'master' into merge

.github/codecov.yml

@@ -0,0 +1 @@
+comment: false

.github/workflows/build.yml

@@ -76,20 +76,10 @@ jobs:
     - name: make coverage
       run: |
         CXX=clang++-10 make -j2 config=coverage coverage
-    - name: debug coverage
-      run: |
-        git status
-        git log -5
-        echo SHA: $GITHUB_SHA
     - name: upload coverage
-      uses: coverallsapp/github-action@master
+      uses: codecov/codecov-action@v3
       with:
-        path-to-lcov: ./coverage.info
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-    - uses: actions/upload-artifact@v2
-      with:
-        name: coverage
-        path: coverage
+        files: ./coverage.info
 
   web:
     runs-on: ubuntu-latest

README.md

@@ -1,4 +1,4 @@
-Luau ![CI](https://github.com/Roblox/luau/workflows/build/badge.svg) [![Coverage](https://coveralls.io/repos/github/Roblox/luau/badge.svg?branch=master&t=2PXMow)](https://coveralls.io/github/Roblox/luau?branch=master)
+Luau ![CI](https://github.com/Roblox/luau/workflows/build/badge.svg) [![codecov](https://codecov.io/gh/Roblox/luau/branch/master/graph/badge.svg?token=S3U44WN416)](https://codecov.io/gh/Roblox/luau)
 ====
 
 Luau (lowercase u, /ˈlu.aʊ/) is a fast, small, safe, gradually typed embeddable scripting language derived from [Lua](https://lua.org).

docs/_pages/library.md

@@ -360,7 +360,7 @@ Returns `-1` if `n` is negative, `1` if `n` is positive, and `0` if `n` is zero
 function math.round(n: number): number
 ```
 
-Rounds `n` to the nearest integer boundary.
+Rounds `n` to the nearest integer boundary. If `n` is exactly halfway between two integers, rounds `n` away from 0.
 
 ## table library
 

rfcs/README.md

@@ -18,6 +18,13 @@ For changes in semantics, we should be asking:
 - Can it be sandboxed assuming malicious usage?
 - Is it compatible with type checking and other forms of static analysis?
 
+For new standard library functions, we should be asking:
+
+- Is the new functionality used/useful often enough in existing code?
+- Does the standard library implementation carry important performance benefits that can't be achieved in user code?
+- Is the behavior general and unambiguous, as opposed to solving a problem / providing an interface that's too specific?
+- Is the function interface amenable to type checking / linting?
+
 In addition to these questions, we also need to consider that every addition carries a cost, and too many features will result in a language that is harder to learn, harder to implement and ensure consistent implementation quality throughout, slower, etc. In addition, any language is greater than the sum of its parts and features often have non-intuitive interactions with each other.
 
 Since reversing these decisions is incredibly costly and can be impossible due to backwards compatibility implications, all user facing changes to Luau language and core libraries must go through an RFC process.