Following the readme, it generated several unresolved import. When I replaced the source code of overflower-0.1.5/src/lib.rs with the lib.rs, the errors disappears.

    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading overflower v0.1.5
 Downloading overflower_support v0.1.5
   Compiling overflower_support v0.1.5
   Compiling overflower v0.1.5
error[E0432]: unresolved import `syntax::ext::expand::expand_expr`
  --> /home/huang/.cargo/registry/src/github.com-1ecc6299db9ec823/overflower-0.1.5/src/lib.rs:15:27
   |
15 | use syntax::ext::expand::{expand_expr, expand_item};
   |                           ^^^^^^^^^^^ no `expand_expr` in `ext::expand`

error[E0432]: unresolved import `syntax::ext::expand::expand_item`
  --> /home/huang/.cargo/registry/src/github.com-1ecc6299db9ec823/overflower-0.1.5/src/lib.rs:15:40
   |
15 | use syntax::ext::expand::{expand_expr, expand_item};
   |                                        ^^^^^^^^^^^ no `expand_item` in `ext::expand`

error[E0532]: expected tuple struct/variant, found unit variant `MetaItemKind::Word`
   --> /home/huang/.cargo/registry/src/github.com-1ecc6299db9ec823/overflower-0.1.5/src/lib.rs:188:20
    |
188 |             if let MetaItemKind::Word(ref w) = l[0].node {
    |                    ^^^^^^^^^^^^^^^^^^ not a tuple struct/variant

error[E0425]: cannot find function `intern` in module `token`
   --> /home/huang/.cargo/registry/src/github.com-1ecc6299db9ec823/overflower-0.1.5/src/lib.rs:211:35
    |
211 |     reg.register_syntax_extension(token::intern("overflow"),
    |                                   ^^^^^^^^^^^^^ not found in `token`

error: no field `global` on type `&syntax::ast::Path`
   --> /home/huang/.cargo/registry/src/github.com-1ecc6299db9ec823/overflower-0.1.5/src/lib.rs:177:7
    |
177 |     p.global && segs.len() == 3 && any_of(&segs[0], &["std", "core"]) &&
    |       ^^^^^^

error[E0308]: mismatched types
   --> /home/huang/.cargo/registry/src/github.com-1ecc6299db9ec823/overflower-0.1.5/src/lib.rs:174:40
    |
174 |         options.iter().any(|o| name == *o)
    |                                        ^^ expected struct `syntax::symbol::InternedString`, found &str
    |
    = note: expected type `syntax::symbol::InternedString`
               found type `&str`

error[E0023]: this pattern has 2 fields, but the corresponding tuple variant has 1 field
   --> /home/huang/.cargo/registry/src/github.com-1ecc6299db9ec823/overflower-0.1.5/src/lib.rs:183:12
    |
183 |     if let MetaItemKind::List(ref s, ref l) = mi.node {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 1 field, found 2

error: aborting due to 3 previous errors

error: Could not compile `overflower`.

2. In readme, you suggested adding a extern crate overflower_support;, however the compiler would fail due to

error[E0463]: can't find crate for `overflower_support`
 --> src/main.rs:4:1
  |
4 | extern crate overflower_support;
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't find crate

error: aborting due to previous error

This issue can be solved by deleting this statements.

Currently this code:

#[overflow(wrap)]
fn main() {
    let i = 1u8 - 1 - 2;
}

expands to:

fn main() { 
    let i = 1u8 - 1.sub_wrap(2);
}

This is because in tag_method the receiver is noop-folded.

With this change:

diff --git i/src/lib.rs w/src/lib.rs
index 7af31b6..cff4b10 100644
--- i/src/lib.rs
+++ w/src/lib.rs
@@ -102,7 +102,7 @@ impl<'a, 'cx> Folder for Overflower<'a, 'cx> {
 }

 fn tag_method(o: &mut Overflower, name: &str, receiver: P<Expr>, args: Vec<P<Expr>>) -> P<Expr> {
-    let rec = receiver.map(|r| fold::noop_fold_expr(r, o));
+    let rec = receiver.map(|r| o.fold_expr(P(r)).unwrap());
     let fn_name = o.cx.ident_of(&format!("{}_{}", name, o.mode));
     let args_expanded = args.into_iter().map(|a| a.map(|e| fold::noop_fold_expr(e, o))).collect();
     o.cx.expr_method_call(DUMMY_SP, rec, fn_name, args_expanded)

it is correctly expanded:

fn main() { 
    let i = 1u8.sub_wrap(1).sub_wrap(2); 
}

The args are folded using the same noop_fold_expr as well, not sure if that needs to be changed (at least it still compiles and tests are green). I did not submit a PR (yet), because I just unwrap. Do we need proper error handling there? Is it possible this fails at all?

Updates the requirements on quote to permit the latest version.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Updates the requirements on quote to permit the latest version.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Note: This repo was added to Dependabot recently, so you'll receive a maximum of 5 PRs for your first few update runs. Once an update run creates fewer than 5 PRs we'll remove that limit.

You can always request more updates by clicking Bump now in your Dependabot dashboard.

Example code:

#![feature(plugin)]
#![plugin(overflower)]

extern crate overflower_support;

#[overflow(wrap)]
fn it_doesnt_work() {
    let mut a = 0;
    a += 1;
    a -= 1;
    a *= 1;
    a /= 1;
}

Example error:

   Compiling overflower_support v0.1.5
   Compiling overflower v0.4.0
   Compiling mycrate v0.1.0 (file:///...)
error[E0433]: failed to resolve. Could not find `Add_assignWrap` in `overflower_support`
 --> src/lib.rs:9:4
  |
9 |     a += 1;
  |       ^^ Could not find `Add_assignWrap` in `overflower_support`

error[E0433]: failed to resolve. Could not find `Sub_assignWrap` in `overflower_support`
  --> src/lib.rs:10:4
   |
10 |    a -= 1;
   |      ^^ Could not find `Sub_assignWrap` in `overflower_support`

error[E0433]: failed to resolve. Could not find `Mul_assignWrap` in `overflower_support`
  --> src/lib.rs:11:4
   |
11 |    a *= 1;
   |      ^^ Could not find `Mul_assignWrap` in `overflower_support`

error[E0433]: failed to resolve. Could not find `Div_assignWrap` in `overflower_support`
  --> src/lib.rs:12:4
   |
12 |    a /= 1;
   |      ^^ Could not find `Div_assignWrap` in `overflower_support`

error: aborting due to previous error(s)

error: Could not compile `mycrate`.

To learn more, run the command again with --verbose.

This is just an intermittent solution until I get to use the new procedural-attr-macro interface (but that'll need some more rewriting). It doesn't do the right thing with regards to spans, but should otherwise work OK.

This is a problem, because I don't want to do type inference. However, Unified Function Call Syntax (UFCS) to the rescue. We can ask users to use std::*::abs(_) (or core::*::abs(_)) instead and replace the calls directly.

We may even write a lint to check on items with an #[overflow(_)] attribute if there's some .abs() method call on an integer and suggest the appropriate UFCS call.

Dependabot Preview will be shut down on August 3rd, 2021. In order to keep getting Dependabot updates, please merge this PR and migrate to GitHub-native Dependabot before then.

Dependabot has been fully integrated into GitHub, so you no longer have to install and manage a separate app. This pull request migrates your configuration from Dependabot.com to a config file, using the new syntax. When merged, we'll swap out dependabot-preview (me) for a new dependabot app, and you'll be all set!

With this change, you'll now use the Dependabot page in GitHub, rather than the Dependabot dashboard, to monitor your version updates, and you'll configure Dependabot through the new config file rather than a UI.

If you've got any questions or feedback for us, please let us know by creating an issue in the dependabot/dependabot-core repository.

Learn more about migrating to GitHub-native Dependabot

Please note that regular @dependabot commands do not work on this pull request.

Updates the requirements on quickcheck to permit the latest version.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

The lastest travis build failed because thte cache has grown so large that there's no chance it would get unpacked in 10 minutes.

Quite frankly, your project is small and hardly needs any cache at all, just remove it.

This changes the whole crate structure so you can now directly use overflower::overflow if you so desire. Also there's now a way to use overflower on stable Rust, but you will have to implement the overflower traits for all your types you use within #[overflow(..)]-annotated code that has arithmetic operations. The new overflower::impls!(..) macro lets you do that quite easily.

I wonder if overflower should have a mode that avoids panics distinct from wrap/saturate to do whatever on overflow (e.g. return 0) but avoid panic.

The rationale is that even with wrap (and as of yet saturate), division/remainder can panic when dividing by zero. I don't want to have different semantics from the original wrapping methods, and saturate is more complex and likely slower.