Fix misspelled comments.
Reviewed-by: steveklabnik
Rust was written by these fine people:
+A.J. Gardner <mrhota@users.noreply.github.com>
+Aaron Friel <mayreply@aaronfriel.com>
Aaron Laursen <aaronlaursen@gmail.com>
+Aaron Liblong <liblonga@physics.utoronto.ca>
Aaron Raimist <aaron@aaronraimist.com>
Aaron Todd <github@opprobrio.us>
Aaron Turon <aturon@mozilla.com>
+Aaron Weiss <aaronweiss74@gmail.com>
Adam Bozanich <adam.boz@gmail.com>
+Adam Szkoda <adaszko@gmail.com>
Adolfo Ochagavía <aochagavia92@gmail.com>
Adrien Brault <adrien.brault@gmail.com>
Adrien Tétar <adri-from-59@hotmail.fr>
Ahmed Charles <ahmedcharles@gmail.com>
+Aidan Cully <github@aidan.users.panix.com>
+Akos Kiss <akiss@inf.u-szeged.hu>
Alan Andrade <alan.andradec@gmail.com>
Alan Williams <mralert@gmail.com>
Aleksander Balicki <balicki.aleksander@gmail.com>
+Aleksandr Koshlo <sash7ko@gmail.com>
Alex Crichton <alex@alexcrichton.com>
Alex Gaynor <alex.gaynor@gmail.com>
Alex Lyon <arcterus@mail.com>
Amy Unger <amy.e.unger@gmail.com>
Anders Kaseorg <andersk@mit.edu>
Andre Arko <andre@arko.net>
+Andrea Canciani <ranma42@gmail.com>
Andreas Gal <gal@mozilla.com>
Andreas Martens <andreasm@fastmail.fm>
Andreas Neuhaus <zargony@zargony.com>
Andreas Ots <andreasots@gmail.com>
Andreas Tolfsen <ato@mozilla.com>
Andrei Formiga <archimedes_siracusa@hotmail.com>
+Andrew Cann <shum@canndrew.org>
Andrew Chin <achin@eminence32.net>
Andrew Dunham <andrew@du.nham.ca>
Andrew Gallant <jamslam@gmail.com>
Andrew Paseltiner <apaseltiner@gmail.com>
Andrew Poelstra <asp11@sfu.ca>
+Andrew Wagner <drewm1980@gmail.com>
Angus Lees <gus@inodes.org>
Anthony Juckel <ajuckel@gmail.com>
-Anton Lofgren <alofgren@op5.com>
Anton Löfgren <anton.lofgren@gmail.com>
Arcterus <Arcterus@mail.com>
-Ariel Ben-Yehuda <arielb1@mail.tau.ac.il>
+Ariel Ben-Yehuda <ariel.byd@gmail.com>
Arjan Topolovec <arjan.top@gmail.com>
Arkaitz Jimenez <arkaitzj@gmail.com>
Armin Ronacher <armin.ronacher@active-4.com>
Arpad Borsos <arpad.borsos@googlemail.com>
+Artem <artemciy@gmail.com>
+Arthur Liao <arthurtw8@gmail.com>
Ashok Gautham <ScriptDevil@gmail.com>
Austin Bonander <austin.bonander@gmail.com>
Austin King <shout@ozten.com>
Austin Seipp <mad.one@gmail.com>
Axel Viala <axel.viala@darnuria.eu>
Aydin Kim <ladinjin@hanmail.net>
+Barosl Lee <vcs@barosl.com>
Ben Alpert <ben@benalpert.com>
Ben Blum <bblum@andrew.cmu.edu>
+Ben Foppa <benjamin.foppa@gmail.com>
Ben Gamari <bgamari.foss@gmail.com>
Ben Harris <mail@bharr.is>
Ben Kelly <ben@wanderview.com>
Ben Noordhuis <info@bnoordhuis.nl>
+Ben S <ogham@bsago.me>
Ben Striegel <ben.striegel@gmail.com>
Benjamin Adamson <adamson.benjamin@gmail.com>
Benjamin Herr <ben@0x539.de>
Benjamin Jackman <ben@jackman.biz>
Benjamin Kircher <benjamin.kircher@gmail.com>
Benjamin Peterson <benjamin@python.org>
-Bheesham Persaud <bheesham.persaud@live.ca>
+Bheesham Persaud <bheesham123@hotmail.com>
Bilal Husain <bilal@bilalhusain.com>
Bill Fallon <bill.fallon@robos.li>
Bill Myers <bill_myers@outlook.com>
Bill Wendling <wendling@apple.com>
Birunthan Mohanathas <birunthan@mohanathas.com>
Björn Steinbrink <bsteinbr@gmail.com>
-Boris Egorov <jightuse@gmail.com>
+Boris Egorov <egorov@linux.com>
Bouke van der Bijl <boukevanderbijl@gmail.com>
-Brandon Sanderson <singingboyo@hotmail.com>
+Brandon Sanderson <singingboyo@gmail.com>
Brandon Waskiewicz <brandon.waskiewicz@gmail.com>
Branimir <branimir@volomp.com>
Brendan Cully <brendan@kublai.com>
Brett Cannon <brett@python.org>
Brian Anderson <banderson@mozilla.com>
Brian Dawn <brian.t.dawn@gmail.com>
+Brian J Brennan <brianloveswords@gmail.com>
Brian J. Burg <burg@cs.washington.edu>
Brian Koropoff <bkoropoff@gmail.com>
Brian Leibig <brian.leibig@gmail.com>
Cameron Zwarich <zwarich@mozilla.com>
Carl-Anton Ingmarsson <mail@carlanton.se>
Carlos <toqueteos@gmail.com>
-Carol Nichols <carol.nichols@gmail.com>
+Carol Nichols <cnichols@thinkthroughmath.com>
Carol Willing <carolcode@willingconsulting.com>
Carter Tazio Schonwald <carter.schonwald@gmail.com>
+Chase Southwood <chase.southwood@gmail.com>
Chris Double <chris.double@double.co.nz>
Chris Morgan <me@chrismorgan.info>
Chris Nixon <chris.nixon@sigma.me.uk>
Chuck Ries <chuck.ries@gmail.com>
Clark Gaebel <cg.wowus.cg@gmail.com>
Clinton Ryan <clint.ryan3@gmail.com>
+Cody P Schafer <dev@codyps.com>
Cody Schroeder <codys@cs.washington.edu>
Cole Mickens <cole.mickens@gmail.com>
Colin Davidson <colrdavidson@gmail.com>
Corey Farwell <coreyf+rust@rwell.org>
Corey Ford <corey@coreyford.name>
Corey Richardson <corey@octayn.net>
+Cristi Burcă <scribu@gmail.com>
DJUrsus <colinvh@divitu.com>
Damian Gryski <damian@gryski.com>
Damien Grassart <damien@grassart.com>
Derek Chiang <derekchiang93@gmail.com>
Derek Guenther <dguenther9@gmail.com>
Derek Harland <derek.harland@finq.co.nz>
+Diego Giagio <diego@giagio.com>
Diego Ongaro <ongaro@cs.stanford.edu>
Diggory Hardy <diggory.hardy@gmail.com>
Dimitri Krassovski <labria@startika.com>
+Dirk Gadsden <dirk@esherido.com>
Dirk Leifeld <leifeld@posteo.de>
Dirkjan Bussink <d.bussink@gmail.com>
Div Shekhar <div@pagerduty.com>
Drew Willcoxon <adw@mozilla.com>
Dylan Braithwaite <dylanbraithwaite1@gmail.com>
Dzmitry Malyshau <kvarkus@gmail.com>
+Earl St Sauver <estsauver@gmail.com>
Eduard Bopp <eduard.bopp@aepsil0n.de>
Eduard Burtescu <edy.burt@gmail.com>
Eduardo Bautista <me@eduardobautista.com>
Elliott Slaughter <elliottslaughter@gmail.com>
Elly Fong-Jones <elly@leptoquark.net>
Emanuel Rylke <ema-fox@web.de>
+Eric Allen <ericpallen@gmail.com>
Eric Biggers <ebiggers3@gmail.com>
Eric Holk <eric.holk@gmail.com>
Eric Holmes <eric@ejholmes.net>
+Eric Kidd <git@randomhacks.net>
Eric Martin <e.a.martin1337@gmail.com>
Eric Reed <ecreed@cs.washington.edu>
Erick Tryzelaar <erick.tryzelaar@gmail.com>
Erik Lyon <elyon001@local.fake>
Erik Price <erik.price16@gmail.com>
Erik Rose <erik@mozilla.com>
+Erwan <erwan.ricq@gmail.com>
Etienne Millon <me@emillon.org>
Eunchong Yu <kroisse@gmail.com>
Evan Klitzke <evan@eklitzke.org>
Evgeny Sologubov
Fabian Deutsch <fabian.deutsch@gmx.de>
Fabrice Desré <fabrice@desre.org>
+FakeKane <andrewyli@gmail.com>
Falco Hirschenberger <falco.hirschenberger@gmail.com>
Fedor Indutny <fedor.indutny@gmail.com>
Felix Crux <felixc@felixcrux.com>
Florian Gilcher <florian.gilcher@asquera.de>
Florian Hahn <flo@fhahn.com>
Florian Hartwig <florian.j.hartwig@gmail.com>
+Florian Wilkens <floya@live.de>
Florian Zeitz <florob@babelmonkeys.de>
Francisco Souza <f@souza.cc>
Franklin Chen <franklinchen@franklinchen.com>
Geoffroy Couprie <geo.couprie@gmail.com>
George Papanikolaou <g3orge.app@gmail.com>
Georges Dubus <georges.dubus@gmail.com>
+Gil Cottle <rc@redtown.org>
Gioele Barabucci <gioele@svario.it>
+Gleb Kozyrev <gleb@gkoz.com>
Glenn Willen <gwillen@nerdnet.org>
Gonçalo Cabrita <_@gmcabrita.com>
-Graham Fawcett <fawcett@uwindsor.ca>
+Graham Fawcett <graham.fawcett@gmail.com>
Grahame Bowland <grahame@angrygoats.net>
Graydon Hoare <graydon@mozilla.com>
Grigoriy <ohaistarlight@gmail.com>
Honza Strnad <hanny.strnad@gmail.com>
Hugo Jobling <hello@thisishugo.com>
Huon Wilson <dbau.pp+github@gmail.com>
+Ian Connolly <iconnolly@mozilla.com>
Ian D. Bollinger <ian.bollinger@gmail.com>
Ian Daniher <it.daniher@gmail.com>
Igor Bukanov <igor@mir2.org>
Isaac Dupree <antispam@idupree.com>
Ivan Enderlin <ivan.enderlin@hoa-project.net>
Ivan Petkov <ivanppetkov@gmail.com>
+Ivan Ukhov <ivan.ukhov@gmail.com>
Ivano Coppola <rgbfirefox@gmail.com>
J. J. Weber <jjweber@gmail.com>
J.C. Moyer <jmoyer1992@gmail.com>
+JONNALAGADDA Srinivas <js@ojuslabs.com>
Jack Heizer <jack.heizer@gmail.com>
Jack Moffitt <jack@metajack.im>
+Jacob Edelman <edelman.jd@gmail.com>
Jacob Harris Cryer Kragh <jhckragh@gmail.com>
Jacob Hegna <jacobhegna@gmail.com>
Jacob Parker <j3parker@csclub.uwaterloo.ca>
Jaemin Moon <jaemin.moon@samsung.com>
Jag Talon <talon.jag@gmail.com>
+Jake Goulding <jake.goulding@gmail.com>
Jake Kaufman <theevocater@gmail.com>
Jake Kerr <kodafox@gmail.com>
Jake Scott <jake.net@gmail.com>
+Jakub Bukaj <jakub@jakub.cc>
Jakub Wieczorek <jakubw@jakubw.net>
James Deng <cnjamesdeng@gmail.com>
James Hurst <jamesrhurst@users.noreply.github.com>
James Lal <james@lightsofapollo.com>
James Laverack <james@jameslaverack.com>
-James Miller <bladeon@gmail.com>
+James Miller <james@aatch.net>
James Rowe <jroweboy@gmail.com>
James Sanders <sanderjd@gmail.com>
James Tranovich <james@openhorizonlabs.com>
Jan Kobler <eng1@koblersystems.de>
Jan Niklas Hasse <jhasse@gmail.com>
Jannis Harder <jix@jixco.de>
+Jared Roesch <roeschinc@gmail.com>
+Jarod Liu <liuyuanzhi@gmail.com>
+Jashank Jeremy <jashank@rulingia.com>
Jason Fager <jfager@gmail.com>
Jason Orendorff <jorendorff@mozilla.com>
Jason Thompson <jason@jthompson.ca>
Jeff Balogh <jbalogh@mozilla.com>
Jeff Muizelaar <jmuizelaar@mozilla.com>
Jeff Olson <olson.jeffery@gmail.com>
+Jeff Parsons <jeffdougson@gmail.com>
Jeffrey Yasskin <jyasskin@gmail.com>
+Jelte Fennema <github-tech@jeltef.nl>
Jens Nockert <jens@nockert.se>
Jeong YunWon <jeong@youknowone.org>
Jeremy Letang <letang.jeremy@gmail.com>
Jesse Ray <jesse@localhost.localdomain>
Jesse Ruderman <jruderman@gmail.com>
Jihyun Yu <jihyun@nclab.kaist.ac.kr>
+Jim Apple <jbapple+rust@google.com>
Jim Blandy <jimb@red-bean.com>
Jim Radford <radford@blackbean.org>
Jimmie Elvenmark <flugsio@gmail.com>
Jimmy Zelinskie <jimmyzelinskie@gmail.com>
Joe Pletcher <joepletcher@gmail.com>
Joe Schafer <joe@jschaf.com>
+Johannes Hoff <johshoff@gmail.com>
Johannes Löthberg <johannes@kyriasis.com>
Johannes Muenzel <jmuenzel@gmail.com>
+John Albietz <inthecloud247@gmail.com>
John Barker <jebarker@gmail.com>
John Clements <clements@racket-lang.org>
John Fresco <john.fresco@utah.edu>
John Gallagher <jgallagher@bignerdranch.com>
+John Kleint <jk@hinge.co>
John Kåre Alsaker <john.kare.alsaker@gmail.com>
John Louis Walker <injyuw@gmail.com>
John Schmidt <john.schmidt.h@gmail.com>
John Simon <john@johnsoft.com>
+Jon Haddad <jon@jonhaddad.com>
Jon Morton <jonanin@gmail.com>
Jonas Hietala <tradet.h@gmail.com>
Jonathan Bailey <jbailey@mozilla.com>
Jonathan Reem <jonathan.reem@gmail.com>
Jonathan S <gereeter@gmail.com>
Jonathan Sternberg <jonathansternberg@gmail.com>
+Joonas Javanainen <joonas.javanainen@gmail.com>
Jordi Boggiano <j.boggiano@seld.be>
-Jorge Aparicio <japaric@linux.com>
+Jorge Aparicio <japaricious@gmail.com>
Joris Rehm <joris.rehm@wakusei.fr>
Joseph Crail <jbcrail@gmail.com>
Joseph Martin <pythoner6@gmail.com>
+Joseph Rushton Wakeling <joe@webdrake.net>
+Josh Haberman <jhaberman@gmail.com>
Josh Matthews <josh@joshmatthews.net>
+Josh Stone <cuviper@gmail.com>
Joshua Clark <joshua.clark@txstate.edu>
Joshua Wise <joshua@joshuawise.com>
Joshua Yanovski <pythonesque@gmail.com>
Justin Noah <justinnoah@gmail.com>
Jyun-Yan You <jyyou.tw@gmail.com>
Kang Seonghoon <kang.seonghoon@mearie.org>
+Kang Seonghoon <public+git@mearie.org>
Kasey Carrothers <kaseyc.808@gmail.com>
Keegan McAllister <kmcallister@mozilla.com>
Kelly Wilson <wilsonk@cpsc.ucalgary.ca>
+Ken Tossell <ken@tossell.net>
Keshav Kini <keshav.kini@gmail.com>
Kevin Atkinson <kevina@cs.utah.edu>
Kevin Ballard <kevin@sb.org>
Kevin Mehall <km@kevinmehall.net>
Kevin Murphy <kemurphy.cmu@gmail.com>
Kevin Walter <kevin.walter.private@googlemail.com>
+Kevin Yap <me@kevinyap.ca>
Kiet Tran <ktt3ja@gmail.com>
Kyeongwoon Lee <kyeongwoon.lee@samsung.com>
Lars Bergstrom <lbergstrom@mozilla.com>
+Laurence Tratt <laurie@tratt.net>
Laurent Bonnans <bonnans.l@gmail.com>
Lawrence Velázquez <larryv@alum.mit.edu>
Leah Hanson <astrieanna@gmail.com>
Léo Testard <leo.testard@gmail.com>
Liigo Zhuang <com.liigo@gmail.com>
Lindsey Kuper <lindsey@composition.al>
+Lionel Flandrin <lionel.flandrin@parrot.com>
Luca Bruno <lucab@debian.org>
Luis de Bethencourt <luis@debethencourt.com>
+Luke Metz <luke.metz@students.olin.edu>
Luqman Aden <me@luqman.ca>
Magnus Auvinen <magnus.auvinen@gmail.com>
Mahmut Bulut <mahmutbulut0@gmail.com>
Mark Rowe <mrowe@bdash.net.nz>
Mark Sinclair <mark.edward.x@gmail.com>
Mark Vian <mrv.caseus@gmail.com>
+Markus Siemens <siemens1993@gmail.com>
Markus Unterwaditzer <markus@unterwaditzer.net>
Marti Raudsepp <marti@juffo.org>
Martin DeMello <martindemello@gmail.com>
Martin Olsson <martin@minimum.se>
+Martin Pool <mbp@sourcefrog.net>
Marvin Löbel <loebel.marvin@gmail.com>
Matej Lach <matej.lach@gmail.com>
Mateusz Czapliński <czapkofan@gmail.com>
+Mathieu Poumeyrol <kali@zoy.org>
Mathijs van de Nes <git@mathijs.vd-nes.nl>
Matt Brubeck <mbrubeck@limpet.net>
Matt Carberry <carberry.matt@gmail.com>
Matt Coffin <mcoffin13@gmail.com>
+Matt McPherrin <git@mcpherrin.ca>
+Matt Murphy <matthew.john.murphy@gmail.com>
+Matt Windsor <mattwindsor@btinternet.com>
Matthew Auld <matthew.auld@intel.com>
Matthew Iselin <matthew@theiselins.net>
Matthew McPherrin <matthew@mcpherrin.ca>
Matthijs van der Vleuten <git@zr40.nl>
Max Penet <max.penet@gmail.com>
Maxim Kolganov <kolganov.mv@gmail.com>
+Maxime Quandalle <maxime@quandalle.com>
+Maximilian Haack <mxhaack@gmail.com>
+Maya Nitu <maya_nitu@yahoo.com>
Meyer S. Jacobs <meyermagic@gmail.com>
Micah Chalmer <micah@micahchalmer.net>
Michael Arntzenius <daekharel@gmail.com>
Michael Dagitses <dagitses@google.com>
Michael Darakananda <pongad@gmail.com>
Michael Fairley <michaelfairley@gmail.com>
+Michael Gehring <mg@ebfe.org>
Michael Kainer <kaini1123@gmail.com>
Michael Letterle <michael.letterle@gmail.com>
Michael Matuzak <mmatuzak@gmail.com>
Mickaël Delahaye <mickael.delahaye@gmail.com>
Mihnea Dobrescu-Balaur <mihnea@linux.com>
Mike Boutin <mike.boutin@gmail.com>
+Mike Dilger <mike@efx.co.nz>
+Mike Pedersen <noctune9@gmail.com>
Mike Robinson <mikeprobinsonuk@gmail.com>
Mikko Perttunen <cyndis@kapsi.fi>
Ms2ger <ms2ger@gmail.com>
Mukilan Thiagarajan <mukilanthiagarajan@gmail.com>
+Mukilan Thiyagarajan <mukilanthiagarajan@gmail.com>
+Murarth <murarth@gmail.com>
NODA, Kai <nodakai@gmail.com>
+Nafis <nhoss2@gmail.com>
Nathan Froyd <froydnj@gmail.com>
Nathan Typanski <ntypanski@gmail.com>
+Nathan Zadoks <nathan@nathan7.eu>
Nathaniel Herman <nherman@college.harvard.edu>
+Neil Pankey <npankey@gmail.com>
NiccosSystem <niccossystem@gmail.com>
+Nicholas Bishop <nicholasbishop@gmail.com>
Nick Cameron <ncameron@mozilla.com>
Nick Desaulniers <ndesaulniers@mozilla.com>
Nick Howell <howellnick@gmail.com>
Nicolas Silva <nical.silva@gmail.com>
+Niels Egberts <git@nielsegberts.nl>
Niels langager Ellegaard <niels.ellegaard@gmail.com>
Nif Ward <nif.ward@gmail.com>
Nikita Pekin <contact@nikitapek.in>
Noufal Ibrahim <noufal@nibrahim.net.in>
O S K Chaitanya <osk@medhas.org>
OGINO Masanori <masanori.ogino@gmail.com>
+Oliver Schneider <oliver.schneider@kit.edu>
Olivier Saut <osaut@airpost.net>
Olle Jonsson <olle.jonsson@gmail.com>
Or Brostovski <tohava@gmail.com>
Pablo Brasero <pablo@pablobm.com>
Palmer Cox <p@lmercox.com>
Paolo Falabella <paolo.falabella@gmail.com>
+Pascal Hertleif <killercup@gmail.com>
Patrick Reisert <kpreisert@gmail.com>
Patrick Walton <pcwalton@mimiga.net>
Patrick Yevsukov <patrickyevsukov@users.noreply.github.com>
Patrik Kårlin <patrik.karlin@gmail.com>
-Paul Collins <paul@ondioline.org>
+Paul Collier <paul@paulcollier.ca>
Paul Stansifer <paul.stansifer@gmail.com>
Paul Woolcock <pwoolcoc+github@gmail.com>
Pavel Panchekha <me@pavpanchekha.com>
Pawel Olzacki <p.olzacki2@samsung.com>
+Pedro Larroy <pedro.larroy@here.com>
Peer Aramillo Irizar <peer.aramillo.irizar@gmail.com>
Peter Atashian <retep998@gmail.com>
+Peter Elmers <peter.elmers@yahoo.com>
Peter Hull <peterhull90@gmail.com>
Peter Marheine <peter@taricorp.net>
Peter Williams <peter@newton.cx>
Peter Zotov <whitequark@whitequark.org>
Petter Remen <petter.remen@gmail.com>
-Phil Dawes <phil@phildawes.net>
+Phil Dawes <pdawes@drw.com>
Phil Ruffwind <rf@rufflewind.com>
+Philip Munksgaard <pmunksgaard@gmail.com>
Philipp Brüschweiler <blei42@gmail.com>
Philipp Gesang <phg42.2a@gmail.com>
Piotr Czarnecki <pioczarn@gmail.com>
Piotr Jawniak <sawyer47@gmail.com>
+Piotr Szotkowski <chastell@chastell.net>
Piotr Zolnierek <pz@anixe.pl>
Pradeep Kumar <gohanpra@gmail.com>
Prudhvi Krishna Surapaneni <me@prudhvi.net>
Randati <anttivan@gmail.com>
Raphael Catolino <raphael.catolino@gmail.com>
Raphael Speyer <rspeyer@gmail.com>
+Ray Clanan <rclanan@utopianconcept.com>
Reilly Watson <reillywatson@gmail.com>
Renato Riccieri Santos Zannon <renato@rrsz.com.br>
Renato Zannon <renato@rrsz.com.br>
Richard Diamond <wichard@vitalitystudios.com>
Richo Healey <richo@psych0tik.net>
Rick Waldron <waldron.rick@gmail.com>
+Ricky Taylor <rickytaylor26@gmail.com>
Rob Arnold <robarnold@cs.cmu.edu>
Rob Hoelz <rob@hoelz.ro>
Robert Buonpastore <robert.buonpastore@gmail.com>
Robert Irelan <rirelan@gmail.com>
Robert Knight <robertknight@gmail.com>
Robert Millar <robert.millar@cantab.net>
+Robin Gloster <robin@loc-com.de>
+Robin Stocker <robin@nibor.org>
+Rohit Joshi <rohit.joshi@capitalone.com>
Roland Tanglao <roland@rolandtanglao.com>
-Rolf Timmermans <r.w.timmermans@gmail.com>
+Rolf Timmermans <rolftimmermans@voormedia.com>
+Rolf van de Krol <info@rolfvandekrol.nl>
Ron Dahlgren <ronald.dahlgren@gmail.com>
+Roy Crihfield <rscrihf@gmail.com>
Roy Frostig <rfrostig@mozilla.com>
Russell <rpjohnst@gmail.com>
Ruud van Asseldonk <dev@veniogames.com>
Scott Jenkins <scottdjwales@gmail.com>
Scott Lawrence <bytbox@gmail.com>
Sean Chalmers <sclhiannan@gmail.com>
+Sean Collins <sean@cllns.com>
Sean Gillespie <sean.william.g@gmail.com>
+Sean Jensen-Grey <seanj@xyke.com>
Sean McArthur <sean.monstar@gmail.com>
Sean Moon <ssamoon@ucla.edu>
Sean Stangl <sstangl@mozilla.com>
+Sean T Allen <sean@monkeysnatchbanana.com>
Sebastian N. Fernandez <cachobot@gmail.com>
Sebastian Zaha <sebastian.zaha@gmail.com>
Sebastien Martini <seb@dbzteam.org>
Seonghyun Kim <sh8281.kim@samsung.com>
Sergio Benitez <sbenitez@mit.edu>
Seth Pink <sethpink@gmail.com>
+Seth Pollack <sethpollack@users.noreply.github.com>
Shamir Khodzha <khodzha.sh@gmail.com>
SiegeLord <slabode@aim.com>
Simon Barber-Dueck <sbarberdueck@gmail.com>
Simon Persson <simon@flaskpost.org>
-Simon Sapin <simon@exyr.org>
+Simon Sapin <simon.sapin@exyr.org>
+Simon Wollwage <mail.wollwage@gmail.com>
+Simonas Kazlauskas <git@kazlauskas.me>
+Son <leson.phung@gmail.com>
Squeaky <squeaky_pl@gmx.com>
+Stefan Bucur <stefan.bucur@epfl.ch>
Stefan Plantikow <stefan.plantikow@googlemail.com>
Stepan Koltsov <stepan.koltsov@gmail.com>
Sterling Greene <sterling.greene@gmail.com>
Steven Sheldon <steven@sasheldon.com>
Steven Stewart-Gallus <sstewartgallus00@langara.bc.ca>
Strahinja Val Markovic <val@markovic.io>
-Stuart Pernsteiner <spernsteiner@mozilla.com>
+Stuart Pernsteiner <stuart@pernsteiner.org>
+Subhash Bhushan <subhash.bhushan@kaybus.com>
Sylvestre Ledru <sylvestre@debian.org>
Sébastien Chauvel <eichi237@mailoo.org>
Sébastien Crozet <developer@crozet.re>
Sébastien Paolacci <sebastien.paolacci@gmail.com>
+Tamir Duberstein <tamird@squareup.com>
Taras Shpot <mrshpot@gmail.com>
+Taylor Hutchison <seanthutchison@gmail.com>
Ted Horst <ted.horst@earthlink.net>
Thad Guidry <thadguidry@gmail.com>
Thomas Backman <serenity@exscape.org>
Tim Joseph Dumol <tim@timdumol.com>
Tim Kuehn <tkuehn@cmu.edu>
Tim Taubert <tim@timtaubert.de>
+Timon Rapp <timon@zaeda.net>
Timothée Ravier <tim@siosm.fr>
+Titouan Vervack <tivervac@gmail.com>
Tobba <tobias.haegermarck@gmail.com>
Tobias Bucher <tobiasbucher5991@gmail.com>
Tohava <tohava@tohava-laptop.(none)>
Tycho Sci <tychosci@gmail.com>
Tyler Bindon <martica@martica.org>
U-NOV2010\eugals
+Ulysse Carion <ulysse@ulysse.io>
Utkarsh Kukreti <utkarshkukreti@gmail.com>
Uwe Dauernheim <uwe@dauernheim.net>
Vadim Chugunov <vadimcn@gmail.com>
+Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Valentin Tsatskin <vtsatskin@mozilla.com>
Valerii Hiora <valerii.hiora@gmail.com>
Victor Berger <victor.berger@m4x.org>
+Victor van den Elzen <victor.vde@gmail.com>
Vijay Korapaty <rust@korapaty.com>
Viktor Dahl <pazaconyoman@gmail.com>
Vincent Belliard <vincent@famillebelliard.fr>
Vinzent Steinberg <Vinzent.Steinberg@gmail.com>
Virgile Andreani <virgile.andreani@anbuco.fr>
+Vitali Haravy <HumaneProgrammer@gmail.com>
Vivek Galatage <vivekgalatage@gmail.com>
+Vladimir Matveev <vladimir.matweev@gmail.com>
Vladimir Pouzanov <farcaller@gmail.com>
+Vladimir Smola <smola.vladimir@gmail.com>
Volker Mische <volker.mische@gmail.com>
Wade Mealing <wmealing@gmail.com>
WebeWizard <webewizard@gmail.com>
Wendell Smith <wendell.smith@yale.edu>
William Ting <io@williamting.com>
Yasuhiro Fujii <y-fujii@mimosa-pudica.net>
+YawarRaza7349 <YawarRaza7349@gmail.com>
Yazhong Liu <yorkiefixer@gmail.com>
Yehuda Katz <wycats@gmail.com>
+York Xiang <bombless@126.com>
Young-il Choi <duddlf.choi@samsung.com>
Youngmin Yoo <youngmin.yoo@samsung.com>
Youngsoo Son <ysson83@gmail.com>
Zach Pomerantz <zmp@umich.edu>
Zack Corr <zack@z0w0.me>
Zack Slayton <zack.slayton@gmail.com>
-Zbigniew Siciarz <antyqjon@gmail.com>
+Zbigniew Siciarz <zbigniew@siciarz.net>
Ziad Hatahet <hatahet@gmail.com>
Zooko Wilcox-O'Hearn <zooko@zooko.com>
aochagavia <aochagavia92@gmail.com>
+areski <areski@gmail.com>
+arturo <arturo@openframeworks.cc>
auREAX <mark@xn--hwg34fba.ws>
b1nd <clint.ryan3@gmail.com>
bachm <Ab@vapor.com>
blake2-ppc <ulrik.sverdrup@gmail.com>
+bluss <bluss>
+bombless <bombless@126.com>
bors <bors@rust-lang.org>
chitra
chromatic <chromatic@wgz.org>
comex <comexk@gmail.com>
+crhino <piraino.chris@gmail.com>
+dan@daramos.com <dan@daramos.com>
darkf <lw9k123@gmail.com>
dgoon <dgoon@dgoon.net>
donkopotamus <general@chocolate-fish.com>
eliovir <eliovir@gmail.com>
+elszben <notgonna@tellyou>
flo-l <lacknerflo@gmail.com>
fort <e@mail.com>
free-Runner <aali07@students.poly.edu>
iancormac84 <wilnathan@gmail.com>
inrustwetrust <inrustwetrust@users.noreply.github.com>
jamesluke <jamesluke@users.noreply.github.com>
+jbranchaud <jbranchaud@gmail.com>
+jfager <jfager@gmail.com>
jmgrosen <jmgrosen@gmail.com>
+jmu303 <muj@bc.edu>
joaoxsouls <joaoxsouls@gmail.com>
+jrincayc <jrincayc@users.noreply.github.com>
+juxiliary <juxiliary@gmail.com>
+jxv <joevargas@hush.com>
klutzy <klutzytheklutzy@gmail.com>
korenchkin <korenchkin2@gmail.com>
+kulakowski <george.kulakowski@gmail.com>
kvark <kvarkus@gmail.com>
kwantam <kwantam@gmail.com>
lpy <pylaurent1314@gmail.com>
m-r-r <raybaudroigm@gmail.com>
maikklein <maikklein@googlemail.com>
masklinn <github.com@masklinn.net>
+mchaput <matt@whoosh.ca>
mdinger <mdinger.bugzilla@gmail.com>
mitchmindtree <mitchell.nordine@gmail.com>
moonglum <moonglum@moonbeamlabs.com>
nham <hamann.nick@gmail.com>
noam <noam@clusterfoo.com>
novalis <novalis@novalis.org>
+oli-obk <github6541940@oli-obk.de>
+olivren <o.renaud@gmx.fr>
osa1 <omeragacan@gmail.com>
+qwitwa <qwitwa@gmail.com>
reedlepee <reedlepee123@gmail.com>
+rjz <rj@rjzaworski.com>
sevrak <sevrak@rediffmail.com>
+sheroze1123 <mss385@cornell.edu>
smenardpw <sebastien@knoglr.com>
sp3d <sp3d@github>
startling <tdixon51793@gmail.com>
+th0114nd <th0114nd@gmail.com>
theptrk <patrick.tran06@gmail.com>
+thiagopnts <thiagopnts@gmail.com>
tinaun <tinagma@gmail.com>
+tshakah <tshakah@gmail.com>
ville-h <ville3.14159@gmail.com>
+we <vadim.petrochenkov@gmail.com>
+whataloadofwhat <unusualmoniker@gmail.com>
wickerwaka <martin.donlon@gmail.com>
xales <xales@naveria.com>
zofrex <zofrex@gmail.com>
+Version 1.0.0-alpha (January 2015)
+----------------------------------
+
+ * ~2400 changes, numerous bugfixes
+
+ * Highlights
+
+ * The language itself is considered feature complete for 1.0,
+ though there will be many usability improvements and bugfixes
+ before the final release.
+ * Nearly 50% of the public API surface of the standard library has
+ been declared 'stable'. Those interfaces are unlikely to change
+ before 1.0.
+ * The long-running debate over integer types has been
+ [settled][ints]: Rust will ship with types named `isize` and
+ `usize`, rather than `int` and `uint`, for pointer-sized
+ integers. Guidelines will be rolled out during the alpha cycle.
+ * Most crates that are not `std` have been moved out of the Rust
+ distribution into the Cargo ecosystem so they can evolve
+ separately and don't need to be stabilized as quickly, including
+ 'time', 'getopts', 'num', 'regex', and 'term'.
+ * Documentation continues to be expanded with more guides, more
+ API coverage and more examples.
+ * All official Rust binary installers now come with [Cargo], the
+ Rust package manager.
+
+* Language
+
+ * Closures have been [completely redesigned][unboxed] to be
+ implemented in terms of traits, can now be used as generic type
+ bounds and thus monomorphized and inlined, or via an opaque
+ pointer (boxed) as in the old system. The new system is often
+ referred to as 'unboxed' closures.
+ * Traits now support [associated types][assoc], allowing families
+ of related types to be defined together and used generically in
+ powerful ways.
+ * Enum variants are [namespaced by their type names][enum].
+ * [`where` clauses][where] provide a more versatile and attractive
+ syntax for specifying generic bounds, though the previous syntax
+ remains valid.
+ * Rust again picks a [fallback][fb] (either i32 or f64) for uninferred
+ numeric types.
+ * Rust [no longer has a runtime][rt] of any description, and only
+ supports OS threads, not green threads.
+ * At long last, Rust has been overhauled for 'dynamically-sized
+ types' ([DST]), which integrates 'fat pointers' (object types,
+ arrays, and `str`) more deeply into the type system, making it
+ more consistent.
+ * Rust now has a general [range syntax][range], `i..j`, `i..`, and
+ `..j` that produce range types and which, when combined with the
+ `Index` operator and multidispatch, leads to a convenient slice
+ notation, `[i..j]`.
+ * The new range syntax revealed an ambiguity in the fixed-length
+ array syntax, so now fixed length arrays [are written `[T;
+ N]`][arrays].
+ * The `Copy` trait is no longer implemented automatically. Unsafe
+ pointers no longer implement `Sync` and `Send` so types
+ containing them don't automatically either. `Sync` and `Send`
+ are now 'unsafe traits' so one can "forcibly" implement them via
+ `unsafe impl` if a type confirms to the requirements for them
+ even though the internals do not (e.g. structs containing unsafe
+ pointers like `Arc`). These changes are intended to prevent some
+ footguns and are collectively known as [opt-in built-in
+ traits][oibit] (though `Sync` and `Send` will soon become pure
+ library types unknown to the compiler).
+ * Operator traits now take their operands [by value][ops], and
+ comparison traits can use multidispatch to compare one type
+ against multiple other types, allowing e.g. `String` to be
+ compared with `&str`.
+ * `if let` and `while let` are no longer feature-gated.
+ * Rust has adopted a more [uniform syntax for escaping unicode
+ characters][unicode].
+ * `macro_rules!` [has been declared stable][mac]. Though it is a
+ flawed system it is sufficiently popular that it must be usable
+ for 1.0. Effort has gone into [future-proofing][mac-future] it
+ in ways that will allow other macro systems to be developed in
+ parallel, and won't otherwise impact the evolution of the
+ language.
+ * The prelude has been [pared back significantly][prelude] such
+ that it is the minimum necessary to support the most pervasive
+ code patterns, and through [generalized where clauses][where]
+ many of the prelude extension traits have been consolidated.
+ * Rust's rudimentary reflection [has been removed][refl], as it
+ incurred too much code generation for little benefit.
+ * [Struct variants][structvars] are no longer feature-gated.
+ * Trait bounds can be [polymorphic over lifetimes][hrtb]. Also
+ known as 'higher-ranked trait bounds', this crucially allows
+ unboxed closures to work.
+ * Macros invocations surrounded by parens or square brackets and
+ not terminated by a semicolon are [parsed as
+ expressions][macros], which makes expressions like `vec![1i32,
+ 2, 3].len()` work as expected.
+ * Trait objects now implement their traits automatically, and
+ traits that can be coerced to objects now must be [object
+ safe][objsafe].
+ * Automatically deriving traits is now done with `#[derive(...)]`
+ not `#[deriving(...)]` for [consistency with other naming
+ conventions][derive].
+ * Importing the containing module or enum at the same time as
+ items or variants they contain is [now done with `self` instead
+ of `mod`][self], as in use `foo::{self, bar}`
+ * Glob imports are no longer feature-gated.
+ * The `box` operator and `box` patterns have been feature-gated
+ pending a redesign. For now unique boxes should be allocated
+ like other containers, with `Box::new`.
+
+* Libraries
+
+ * A [series][coll1] of [efforts][coll2] to establish
+ [conventions][coll3] for collections types has resulted in API
+ improvements throughout the standard library.
+ * New [APIs for error handling][err] provide ergonomic interop
+ between error types, and [new conventions][err-conv] describe
+ more clearly the recommended error handling strategies in Rust.
+ * The `fail!` macro has been renamed to [`panic!`][panic] so that
+ it is easier to discuss failure in the context of error handling
+ without making clarifications as to whether you are referring to
+ the 'fail' macro or failure more generally.
+ * On Linux, `OsRng` prefers the new, more reliable `getrandom`
+ syscall when available.
+ * The 'serialize' crate has been renamed 'rustc-serialize' and
+ moved out of the distribution to Cargo. Although it is widely
+ used now, it is expected to be superceded in the near future.
+ * The `Show` formatter, typically implemented with
+ `#[derive(Show)]` is [now requested with the `{:?}`
+ specifier][show] and is intended for use by all types, for uses
+ such as `println!` debugging. The new `String` formatter must be
+ implemented by hand, uses the `{}` specifier, and is intended
+ for full-fidelity conversions of things that can logically be
+ represented as strings.
+
+* Tooling
+
+ * [Flexible target specification][flex] allows rustc's code
+ generation to be configured to support otherwise-unsupported
+ platforms.
+ * Rust comes with rust-gdb and rust-lldb scripts that launch their
+ respective debuggers with Rust-appropriate pretty-printing.
+ * The Windows installation of Rust is distributed with the the
+ MinGW components currently required to link binaries on that
+ platform.
+
+* Misc
+
+ * Nullable enum optimizations have been extended to more types so
+ that e.g. `Option<Vec<T>>` and `Option<String>` take up no more
+ space than the inner types themselves.
+ * Work has begun on supporting AArch64.
+
+[Cargo]: https://crates.io
+[unboxed]: http://smallcultfollowing.com/babysteps/blog/2014/11/26/purging-proc/
+[enum]: https://github.com/rust-lang/rfcs/blob/master/text/0390-enum-namespacing.md
+[flex]: https://github.com/rust-lang/rfcs/blob/master/text/0131-target-specification.md
+[err]: https://github.com/rust-lang/rfcs/blob/master/text/0201-error-chaining.md
+[err-conv]: https://github.com/rust-lang/rfcs/blob/master/text/0236-error-conventions.md
+[rt]: https://github.com/rust-lang/rfcs/blob/master/text/0230-remove-runtime.md
+[mac]: https://github.com/rust-lang/rfcs/blob/master/text/0453-macro-reform.md
+[mac-future]: https://github.com/rust-lang/rfcs/pull/550
+[DST]: http://smallcultfollowing.com/babysteps/blog/2014/01/05/dst-take-5/
+[coll1]: https://github.com/rust-lang/rfcs/blob/master/text/0235-collections-conventions.md
+[coll2]: https://github.com/rust-lang/rfcs/blob/master/text/0509-collections-reform-part-2.md
+[coll3]: https://github.com/rust-lang/rfcs/blob/master/text/0216-collection-views.md
+[ops]: https://github.com/rust-lang/rfcs/blob/master/text/0439-cmp-ops-reform.md
+[prelude]: https://github.com/rust-lang/rfcs/blob/master/text/0503-prelude-stabilization.md
+[where]: https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md
+[refl]: https://github.com/rust-lang/rfcs/blob/master/text/0379-remove-reflection.md
+[panic]: https://github.com/rust-lang/rfcs/blob/master/text/0221-panic.md
+[structvars]: https://github.com/rust-lang/rfcs/blob/master/text/0418-struct-variants.md
+[hrtb]: https://github.com/rust-lang/rfcs/blob/master/text/0387-higher-ranked-trait-bounds.md
+[unicode]: https://github.com/rust-lang/rfcs/blob/master/text/0446-es6-unicode-escapes.md
+[oibit]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
+[macros]: https://github.com/rust-lang/rfcs/blob/master/text/0378-expr-macros.md
+[range]: https://github.com/rust-lang/rfcs/blob/master/text/0439-cmp-ops-reform.md#indexing-and-slicing
+[arrays]: https://github.com/rust-lang/rfcs/blob/master/text/0520-new-array-repeat-syntax.md
+[show]: https://github.com/rust-lang/rfcs/blob/master/text/0504-show-stabilization.md
+[derive]: https://github.com/rust-lang/rfcs/blob/master/text/0534-deriving2derive.md
+[self]: https://github.com/rust-lang/rfcs/blob/master/text/0532-self-in-use.md
+[fb]: https://github.com/rust-lang/rfcs/blob/master/text/0212-restore-int-fallback.md
+[objsafe]: https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md
+[assoc]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md
+[ints]: https://github.com/rust-lang/rfcs/pull/544#issuecomment-68760871
+
Version 0.12.0 (October 2014)
-----------------------------
}
}
-impl fmt::Show for Mode {
+impl fmt::String for Mode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let msg = match *self {
+ fmt::String::fmt(match *self {
CompileFail => "compile-fail",
RunFail => "run-fail",
RunPass => "run-pass",
DebugInfoGdb => "debuginfo-gdb",
DebugInfoLldb => "debuginfo-lldb",
Codegen => "codegen",
- };
- msg.fmt(f)
+ }, f)
+ }
+}
+
+impl fmt::Show for Mode {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
}
}
// except according to those terms.
#![crate_type = "bin"]
-#![feature(phase, slicing_syntax, globs, unboxed_closures)]
+#![feature(slicing_syntax, unboxed_closures)]
#![deny(warnings)]
extern crate test;
extern crate getopts;
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
#[macro_use]
extern crate log;
-
extern crate regex;
use std::os;
let matches =
&match getopts::getopts(args_.as_slice(), groups.as_slice()) {
Ok(m) => m,
- Err(f) => panic!("{}", f)
+ Err(f) => panic!("{:?}", f)
};
if matches.opt_present("h") || matches.opt_present("help") {
match regex::Regex::new(s) {
Ok(re) => Some(re),
Err(e) => {
- println!("failed to parse filter /{}/: {}", s, e);
+ println!("failed to parse filter /{}/: {:?}", s, e);
panic!()
}
}
pub fn log_config(config: &Config) {
let c = config;
logv(c, format!("configuration:"));
- logv(c, format!("compile_lib_path: {}", config.compile_lib_path));
- logv(c, format!("run_lib_path: {}", config.run_lib_path));
- logv(c, format!("rustc_path: {}", config.rustc_path.display()));
- logv(c, format!("src_base: {}", config.src_base.display()));
- logv(c, format!("build_base: {}", config.build_base.display()));
+ logv(c, format!("compile_lib_path: {:?}", config.compile_lib_path));
+ logv(c, format!("run_lib_path: {:?}", config.run_lib_path));
+ logv(c, format!("rustc_path: {:?}", config.rustc_path.display()));
+ logv(c, format!("src_base: {:?}", config.src_base.display()));
+ logv(c, format!("build_base: {:?}", config.build_base.display()));
logv(c, format!("stage_id: {}", config.stage_id));
logv(c, format!("mode: {}", config.mode));
logv(c, format!("run_ignored: {}", config.run_ignored));
logv(c, format!("jit: {}", config.jit));
logv(c, format!("target: {}", config.target));
logv(c, format!("host: {}", config.host));
- logv(c, format!("android-cross-path: {}",
+ logv(c, format!("android-cross-path: {:?}",
config.android_cross_path.display()));
- logv(c, format!("adb_path: {}", config.adb_path));
- logv(c, format!("adb_test_dir: {}", config.adb_test_dir));
+ logv(c, format!("adb_path: {:?}", config.adb_path));
+ logv(c, format!("adb_test_dir: {:?}", config.adb_test_dir));
logv(c, format!("adb_device_status: {}",
config.adb_device_status));
match config.test_shard {
Ok(true) => {}
Ok(false) => panic!("Some tests failed"),
Err(e) => {
- println!("I/O failure during tests: {}", e);
+ println!("I/O failure during tests: {:?}", e);
}
}
}
}
pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
- debug!("making tests from {}",
+ debug!("making tests from {:?}",
config.src_base.display());
let mut tests = Vec::new();
let dirs = fs::readdir(&config.src_base).unwrap();
for file in dirs.iter() {
let file = file.clone();
- debug!("inspecting file {}", file.display());
+ debug!("inspecting file {:?}", file.display());
if is_test(config, &file) {
let t = make_test(config, &file, || {
match config.mode {
(which, line)
};
- debug!("line={} which={} kind={} msg={}", line_num, which, kind, msg);
+ debug!("line={} which={:?} kind={:?} msg={:?}", line_num, which, kind, msg);
Some((which, ExpectedError { line: line,
kind: kind,
msg: msg, }))
print!("\n\n");
}
let testfile = Path::new(testfile);
- debug!("running {}", testfile.display());
+ debug!("running {:?}", testfile.display());
let props = header::load_props(&testfile);
debug!("loaded props");
match config.mode {
static RUST_ERR: int = 101;
if !proc_res.status.matches_exit_status(RUST_ERR) {
fatal_proc_rec(
- format!("failure produced the wrong error: {}",
+ format!("failure produced the wrong error: {:?}",
proc_res.status).as_slice(),
proc_res);
}
],
vec!(("".to_string(), "".to_string())),
Some("".to_string()))
- .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
+ .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
procsrv::run("",
config.adb_path.as_slice(),
],
vec!(("".to_string(), "".to_string())),
Some("".to_string()))
- .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
+ .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
let adb_arg = format!("export LD_LIBRARY_PATH={}; \
gdbserver :5039 {}/{}",
vec!(("".to_string(),
"".to_string())),
Some("".to_string()))
- .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
+ .expect(format!("failed to exec `{:?}`", config.adb_path).as_slice());
loop {
//waiting 1 second for gdbserver start
timer::sleep(Duration::milliseconds(1000));
- let result = Thread::spawn(move || {
+ let result = Thread::scoped(move || {
tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
}).join();
if result.is_err() {
debugger_opts.as_slice(),
vec!(("".to_string(), "".to_string())),
None)
- .expect(format!("failed to exec `{}`", gdb_path).as_slice());
+ .expect(format!("failed to exec `{:?}`", gdb_path).as_slice());
let cmdline = {
let cmdline = make_cmdline("",
"arm-linux-androideabi-gdb",
script_str.push_str("set print pretty off\n");
// Add the pretty printer directory to GDB's source-file search path
- script_str.push_str(format!("directory {}\n", rust_pp_module_abs_path)[]);
+ script_str.push_str(&format!("directory {}\n", rust_pp_module_abs_path)[]);
// Load the target executable
- script_str.push_str(format!("file {}\n",
- exe_file.as_str().unwrap().replace("\\", "\\\\"))
- .as_slice());
+ script_str.push_str(&format!("file {}\n",
+ exe_file.as_str().unwrap().replace("\\", "\\\\"))[]);
// Add line breakpoints
for line in breakpoint_lines.iter() {
- script_str.push_str(format!("break '{}':{}\n",
- testfile.filename_display(),
- *line)[]);
+ script_str.push_str(&format!("break '{:?}':{}\n",
+ testfile.filename_display(),
+ *line)[]);
}
script_str.push_str(cmds.as_slice());
.unwrap()
.to_string();
- script_str.push_str(format!("command script import {}\n", rust_pp_module_abs_path[])[]);
+ script_str.push_str(&format!("command script import {}\n", &rust_pp_module_abs_path[])[]);
script_str.push_str("type summary add --no-value ");
script_str.push_str("--python-function lldb_rust_formatters.print_val ");
script_str.push_str("-x \".*\" --category Rust\n");
output_to_check: &str,
proc_res: &ProcRes) {
if props.error_patterns.is_empty() {
- fatal(format!("no error pattern specified in {}",
+ fatal(format!("no error pattern specified in {:?}",
testfile.display()).as_slice());
}
let mut next_err_idx = 0u;
if done { return; }
let missing_patterns =
- props.error_patterns[next_err_idx..];
+ props.error_patterns.index(&(next_err_idx..));
if missing_patterns.len() == 1u {
fatal_proc_rec(format!("error pattern '{}' not found!",
missing_patterns[0]).as_slice(),
}
let prefixes = expected_errors.iter().map(|ee| {
- format!("{}:{}:", testfile.display(), ee.line)
+ format!("{:?}:{}:", testfile.display(), ee.line)
}).collect::<Vec<String> >();
#[cfg(windows)]
None);
if !auxres.status.success() {
fatal_proc_rec(
- format!("auxiliary build of {} failed to compile: ",
+ format!("auxiliary build of {:?} failed to compile: ",
abs_ab.display()).as_slice(),
&auxres);
}
.expect(format!("failed to exec `{}`", config.adb_path).as_slice());
if config.verbose {
- println!("push ({}) {} {} {}",
+ println!("push ({}) {:?} {} {}",
config.target, file.display(),
copy_result.out, copy_result.err);
}
let version = parse_version(&[1, 2, 3, 4]);
match version {
Ok(v) => {
- println!("working with version: {}", v);
+ println!("working with version: {:?}", v);
}
Err(e) => {
- println!("error parsing header: {}", e);
+ println!("error parsing header: {:?}", e);
}
}
```
# let input_1 = T::SpecialA(0);
# let input_2 = T::SpecialA(0);
macro_rules! early_return {
- ($inp:expr $sp:path) => ( // invoke it like `(input_5 SpecialE)`
+ ($inp:expr, $sp:path) => ( // invoke it like `(input_5 SpecialE)`
match $inp {
$sp(x) => { return x; }
_ => {}
);
}
// ...
-early_return!(input_1 T::SpecialA);
+early_return!(input_1, T::SpecialA);
// ...
-early_return!(input_2 T::SpecialB);
+early_return!(input_2, T::SpecialB);
# return 0;
# }
# fn main() {}
# let input_1 = T::SpecialA(0);
# let input_2 = T::SpecialA(0);
macro_rules! early_return {
- ($inp:expr, [ $($sp:path)|+ ]) => (
+ ($inp:expr, [ $($sp:path),+ ]) => (
match $inp {
$(
$sp(x) => { return x; }
)
}
// ...
-early_return!(input_1, [T::SpecialA|T::SpecialC|T::SpecialD]);
+early_return!(input_1, [T::SpecialA,T::SpecialC,T::SpecialD]);
// ...
early_return!(input_2, [T::SpecialB]);
# return 0;
~~~~
macro_rules! biased_match {
// special case: `let (x) = ...` is illegal, so use `let x = ...` instead
- ( ($e:expr) ~ ($p:pat) else $err:stmt ;
+ ( ($e:expr) -> ($p:pat) else $err:stmt ;
binds $bind_res:ident
) => (
let $bind_res = match $e {
};
);
// more than one name; use a tuple
- ( ($e:expr) ~ ($p:pat) else $err:stmt ;
+ ( ($e:expr) -> ($p:pat) else $err:stmt ;
binds $( $bind_res:ident ),*
) => (
let ( $( $bind_res ),* ) = match $e {
# struct T2 { body: T3 }
# enum T3 { Good2(uint), Bad2}
# fn f(x: T1) -> uint {
-biased_match!((x) ~ (T1::Good1(g1, val)) else { return 0 };
+biased_match!((x) -> (T1::Good1(g1, val)) else { return 0 };
binds g1, val );
-biased_match!((g1.body) ~ (T3::Good2(result) )
+biased_match!((g1.body) -> (T3::Good2(result) )
else { panic!("Didn't get good_2") };
binds result );
// complicated stuff goes here
~~~~
# fn main() {}
# macro_rules! b {
- ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )*
+ ( $( ($e:expr) -> ($p:pat) else $err:stmt ; )*
binds $( $bind_res:ident ),*
)
# => (0) }
~~~~
# fn main() {}
# macro_rules! b {
- ( ($e :expr) ~ ($p :pat) else $err :stmt ;
- $( ($e_rest:expr) ~ ($p_rest:pat) else $err_rest:stmt ; )*
+ ( ($e :expr) -> ($p :pat) else $err :stmt ;
+ $( ($e_rest:expr) -> ($p_rest:pat) else $err_rest:stmt ; )*
binds $( $bind_res:ident ),*
)
# => (0) }
macro_rules! biased_match_rec {
// Handle the first layer
- ( ($e :expr) ~ ($p :pat) else $err :stmt ;
- $( ($e_rest:expr) ~ ($p_rest:pat) else $err_rest:stmt ; )*
+ ( ($e :expr) -> ($p :pat) else $err :stmt ;
+ $( ($e_rest:expr) -> ($p_rest:pat) else $err_rest:stmt ; )*
binds $( $bind_res:ident ),*
) => (
match $e {
$p => {
// Recursively handle the next layer
- biased_match_rec!($( ($e_rest) ~ ($p_rest) else $err_rest ; )*
+ biased_match_rec!($( ($e_rest) -> ($p_rest) else $err_rest ; )*
binds $( $bind_res ),*
)
}
// Wrap the whole thing in a `let`.
macro_rules! biased_match {
// special case: `let (x) = ...` is illegal, so use `let x = ...` instead
- ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )*
+ ( $( ($e:expr) -> ($p:pat) else $err:stmt ; )*
binds $bind_res:ident
) => (
let $bind_res = biased_match_rec!(
- $( ($e) ~ ($p) else $err ; )*
+ $( ($e) -> ($p) else $err ; )*
binds $bind_res
);
);
// more than one name: use a tuple
- ( $( ($e:expr) ~ ($p:pat) else $err:stmt ; )*
+ ( $( ($e:expr) -> ($p:pat) else $err:stmt ; )*
binds $( $bind_res:ident ),*
) => (
let ( $( $bind_res ),* ) = biased_match_rec!(
- $( ($e) ~ ($p) else $err ; )*
+ $( ($e) -> ($p) else $err ; )*
binds $( $bind_res ),*
);
)
# enum T3 { Good2(uint), Bad2}
# fn f(x: T1) -> uint {
biased_match!(
- (x) ~ (T1::Good1(g1, val)) else { return 0 };
- (g1.body) ~ (T3::Good2(result) ) else { panic!("Didn't get Good2") };
+ (x) -> (T1::Good1(g1, val)) else { return 0 };
+ (g1.body) -> (T3::Good2(result) ) else { panic!("Didn't get Good2") };
binds val, result );
// complicated stuff goes here
return result + val;
fn main() {
let list: List<int> = List::Cons(1, box List::Cons(2, box List::Cons(3, box List::Nil)));
- println!("{}", list);
+ println!("{:?}", list);
}
```
`deref`, and `add` respectively.
- stack unwinding and general failure; the `eh_personality`, `fail`
and `fail_bounds_checks` lang items.
-- the traits in `std::kinds` used to indicate types that satisfy
+- the traits in `std::markers` used to indicate types of
various kinds; lang items `send`, `sync` and `copy`.
- the marker types and variance indicators found in
- `std::kinds::markers`; lang items `covariant_type`,
+ `std::markers`; lang items `covariant_type`,
`contravariant_lifetime`, `no_sync_bound`, etc.
Lang items are loaded lazily by the compiler; e.g. if one never uses
You should see some output that looks something like this:
```bash
-rustc 0.12.0-nightly (b7aa03a3c 2014-09-28 11:38:01 +0000)
+rustc 1.0.0-nightly (f11f3e7ba 2015-01-04 20:02:14 +0000)
```
If you did, Rust has been installed successfully! Congrats!
`match` is also an expression, which means we can use it on the right-hand
side of a `let` binding or directly where an expression is used. We could
-also implement the previous line like this:
+also implement the previous example like this:
```{rust}
use std::cmp::Ordering;
You can access a particular element of an array with **subscript notation**:
```{rust}
-let names = ["Graydon", "Brian", "Niko"]; // names: [&str, 3]
+let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3]
println!("The second name is: {}", names[1]);
```
parameter. For example, if we wanted something like our `OptionalInt`, we would
need to instantiate an `Option<i32>`. Inside the declaration of our enum,
wherever we see a `T`, we replace it with the type specified (or inferred by the
-the compiler).
+compiler).
```{rust}
let x: Option<i32> = Some(5);
for _ in range(0u, 10u) {
Thread::spawn(move || {
println!("Hello, world!");
- }).detach();
+ });
}
}
```
double bars `||`. (The `move` keyword indicates that the closure takes
ownership of any data it uses; we'll have more on the significance of
this shortly.) This closure is executed in a new thread created by
-`spawn`. The `detach` method means that the child thread is allowed to
-outlive its parent.
+`spawn`.
One common form of problem in concurrent programs is a 'data race.'
This occurs when two different threads attempt to access the same
for i in range(0u, 3u) {
Thread::spawn(move || {
for j in range(0, 3) { numbers[j] += 1 }
- }).detach();
+ });
}
}
```
(*array)[i] += 1;
println!("numbers[{}] is {}", i, (*array)[i]);
- }).detach();
+ });
}
}
```
In the matcher, `$` _name_ `:` _designator_ matches the nonterminal in the Rust
syntax named by _designator_. Valid designators are `item`, `block`, `stmt`,
-`pat`, `expr`, `ty` (type), `ident`, `path`, `matchers` (lhs of the `=>` in
-macro rules), `tt` (rhs of the `=>` in macro rules). In the transcriber, the
-designator is already known, and so only the name of a matched nonterminal
-comes after the dollar sign.
+`pat`, `expr`, `ty` (type), `ident`, `path`, `tt` (either side of the `=>`
+in macro rules). In the transcriber, the designator is already known, and so
+only the name of a matched nonterminal comes after the dollar sign.
In both the matcher and transcriber, the Kleene star-like operator indicates
repetition. The Kleene star operator consists of `$` and parens, optionally
enum_member_count = len(enum_members)
if enum_member_count == 0:
- return RustStructPrinter(val, false)
+ return RustStructPrinter(val, False)
if enum_member_count == 1:
first_variant_name = enum_members[0].name
return rust_pretty_printer_lookup_function(val[enum_members[0]])
else:
assert first_variant_name.startswith("RUST$ENCODED$ENUM$")
- # This is a space-optimized enum
+ # This is a space-optimized enum.
+ # This means this enum has only two states, and Rust uses one of the
+ # fields somewhere in the struct to determine which of the two states
+ # it's in. The location of the field is encoded in the name as something
+ # like RUST$ENCODED$ENUM$(num$)*name_of_zero_state
last_separator_index = first_variant_name.rfind("$")
- second_last_separator_index = first_variant_name.rfind("$", 0, last_separator_index)
- disr_field_index = first_variant_name[second_last_separator_index + 1 :
- last_separator_index]
- disr_field_index = int(disr_field_index)
+ start_index = len("RUST$ENCODED$ENUM$")
+ disr_field_indices = first_variant_name[start_index :
+ last_separator_index].split("$")
+ disr_field_indices = [int(index) for index in disr_field_indices]
sole_variant_val = val[enum_members[0]]
- disr_field = get_field_at_index(sole_variant_val, disr_field_index)
- discriminant = sole_variant_val[disr_field]
+ discriminant = sole_variant_val
+ for disr_field_index in disr_field_indices:
+ disr_field = get_field_at_index(discriminant, disr_field_index)
+ discriminant = discriminant[disr_field]
# If the discriminant field is a fat pointer we have to consider the
# first word as the true discriminant
if discriminant.type.code == gdb.TYPE_CODE_STRUCT:
- discriminant = discriminant[get_field_at_index(discriminant, 0)]
+ discriminant = discriminant[get_field_at_index(discriminant, 0)]
if discriminant == 0:
null_variant_name = first_variant_name[last_separator_index + 1:]
for field in val.type.fields():
if i == index:
return field
+ i += 1
return None
<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">
<!ENTITY rustIntSuf "([iu](8|16|32|64)?)?">
]>
-<language name="Rust" version="0.13.0" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
+<language name="Rust" version="1.0.0" kateversion="2.4" section="Sources" extensions="*.rs" mimetype="text/x-rust" priority="15">
<highlighting>
<list name="fn">
<item> fn </item>
has_field_names = type_has_field_names(t)
if has_field_names:
- template = "%(type_name)s {\n%(body)s\n}"
- separator = ", \n"
+ template = "%(type_name)s {\n%(body)s\n}"
+ separator = ", \n"
else:
- template = "%(type_name)s(%(body)s)"
- separator = ", "
+ template = "%(type_name)s(%(body)s)"
+ separator = ", "
if type_name.startswith("("):
# this is a tuple, so don't print the type name
if last_separator_index == -1:
return "<invalid enum encoding: %s>" % first_variant_name
- second_last_separator_index = first_variant_name.rfind("$", 0, last_separator_index)
- if second_last_separator_index == -1:
- return "<invalid enum encoding: %s>" % first_variant_name
+ start_index = len("RUST$ENCODED$ENUM$")
- # Extract index of the discriminator field
+ # Extract indices of the discriminator field
try:
- disr_field_index = first_variant_name[second_last_separator_index + 1 :
- last_separator_index]
- disr_field_index = int(disr_field_index)
+ disr_field_indices = first_variant_name[start_index :
+ last_separator_index].split("$")
+ disr_field_indices = [int(index) for index in disr_field_indices]
except:
return "<invalid enum encoding: %s>" % first_variant_name
# Read the discriminant
- disr_val = val.GetChildAtIndex(0).GetChildAtIndex(disr_field_index)
+ disr_val = val.GetChildAtIndex(0)
+ for index in disr_field_indices:
+ disr_val = disr_val.GetChildAtIndex(index)
# If the discriminant field is a fat pointer we have to consider the
# first word as the true discriminant
if disr_val.GetType().GetTypeClass() == lldb.eTypeClassStruct:
- disr_val = disr_val.GetChildAtIndex(0)
+ disr_val = disr_val.GetChildAtIndex(0)
if disr_val.GetValueAsUnsigned() == 0:
# Null case: Print the name of the null-variant
_rustc_emit_types=(
'asm'
- 'bc'
- 'ir'
+ 'llvm-bc'
+ 'llvm-ir'
'obj'
'link'
+ 'dep-info'
)
_rustc_pretty_types=(
'normal[un-annotated source]'
'expanded[crates expanded]'
'typed[crates expanded, with type annotations]'
'identified[fully parenthesized, AST nodes and blocks with IDs]'
- 'flowgraph=[graphviz formatted flowgraph for node]:NODEID:'
+ 'flowgraph[graphviz formatted flowgraph for node]:NODEID:'
)
_rustc_color_types=(
'auto[colorize, if output goes to a tty (default)]'
'always[always colorize output]'
'never[never colorize output]'
)
+_rustc_info_types=(
+ 'crate-name[Output the crate name and exit]'
+ 'file-names[Output the file(s) that would be written if compilation continued and exited]'
+ 'sysroot[Output the sysroot and exit]'
+)
_rustc_opts_vals=(
--crate-name='[Specify the name of the crate being built]'
--crate-type='[Comma separated list of types of crates for the compiler to emit]:TYPES:_values -s "," "Crate types" "$_rustc_crate_types[@]"'
--emit='[Comma separated list of types of output for the compiler to emit]:TYPES:_values -s "," "Emit Targets" "$_rustc_emit_types[@]"'
- --debuginfo='[Emit DWARF debug info to the objects created]:LEVEL:_values "Debug Levels" "$_rustc_debuginfo_levels[@]"'
- --dep-info='[Output dependency info to <filename> after compiling]::FILE:_files -/'
- --sysroot='[Override the system root]:PATH:_files -/'
--cfg='[Configure the compilation environment]:SPEC:'
--out-dir='[Write output to compiler-chosen filename in <dir>. Ignored if -o is specified. (default the current directory)]:DIR:_files -/'
-o'[Write output to <filename>. Ignored if more than one --emit is specified.]:FILENAME:_files'
- --opt-level='[Optimize with possible levels 0-3]:LEVEL:(0 1 2 3)'
--pretty='[Pretty-print the input instead of compiling]::TYPE:_values "TYPES" "$_rustc_pretty_types[@]"'
-L'[Add a directory to the library search path]:DIR:_files -/'
--target='[Target triple cpu-manufacturer-kernel\[-os\] to compile]:TRIPLE:'
{-v,--version}'[Print version info and exit]::VERBOSE:(verbose)'
--explain='[Provide a detailed explanation of an error message]:OPT:'
--extern'[Specify where an external rust library is located]:ARG:'
+ --print='[Comma separated list of compiler information to print on stdout]:TYPES:_values -s "," "Compiler Information" "$_rustc_info_types[@]"'
)
_rustc_opts_switches=(
- -g'[Equivalent to --debuginfo=2]'
- {-h,--help}'[Display this message]'
- --no-analysis'[Parse and expand the output, but run no analysis or produce output]'
- --no-trans'[Run all passes except translation; no output]'
- -O'[Equivalent to --opt-level=2]'
- --parse-only'[Parse only; do not compile, assemble, or link]'
- --print-crate-name'[Output the crate name and exit]'
- --print-file-name'[Output the file(s) that would be written if compilation continued and exit]'
+ -g'[Equivalent to -C debuginfo=2]'
+ {-h,--help}'[Display the help message]'
+ {-V,--verbose}'[use verbose output]'
+ -O'[Equivalent to -C opt-level=2]'
--test'[Build a test harness]'
)
+
+
+_rustc_opts_link=(
+ 'static[Path to the library to link statically]:PATH:_files -/'
+ 'dylib[Path to the library to link dynamically]:PATH:_files -/'
+ 'framework[Path to the library to link as a framework]:PATH:_files -/'
+)
+
_rustc_opts_codegen=(
- 'ar=[Path to the archive utility to use when assembling archives.]:BIN:_path_files'
- 'linker=[Path to the linker utility to use when linking libraries, executables, and objects.]:BIN:_path_files'
- 'link-args=[A space-separated list of extra arguments to pass to the linker when the linker is invoked.]:ARGS:'
- 'target-cpu=[Selects a target processor. If the value is "help", then a list of available CPUs is printed.]:CPU:'
- 'target-feature=[A space-separated list of features to enable or disable for the target. A preceding "+" enables a feature while a preceding "-" disables it. Available features can be discovered through target-cpu=help.]:FEATURE:'
- 'passes=[A space-separated list of extra LLVM passes to run. A value of "list" will cause rustc to print all known passes and exit. The passes specified are appended at the end of the normal pass manager.]:LIST:'
- 'llvm-args=[A space-separated list of arguments to pass through to LLVM.]:ARGS:'
+ 'ar[Path to the archive utility to use when assembling archives.]:BIN:_path_files'
+ 'linker[Path to the linker utility to use when linking libraries, executables, and objects.]:BIN:_path_files'
+ 'link-args[A space-separated list of extra arguments to pass to the linker when the linker is invoked.]:ARGS:'
+ 'lto[Perform LLVM link-time optimizations]'
+ 'target-cpu[Selects a target processor. If the value is "help", then a list of available CPUs is printed.]:CPU:'
+ 'target-feature[A space-separated list of features to enable or disable for the target. A preceding "+" enables a feature while a preceding "-" disables it. Available features can be discovered through target-cpu=help.]:FEATURE:'
+ 'passes[A space-separated list of extra LLVM passes to run. A value of "list" will cause rustc to print all known passes and exit. The passes specified are appended at the end of the normal pass manager.]:LIST:'
+ 'llvm-args[A space-separated list of arguments to pass through to LLVM.]:ARGS:'
'save-temps[If specified, the compiler will save more files (.bc, .o, .no-opt.bc) generated throughout compilation in the output directory.]'
'rpath[If specified, then the rpath value for dynamic libraries will be set in either dynamic library or executable outputs.]'
'no-prepopulate-passes[Suppresses pre-population of the LLVM pass manager that is run over the module.]'
'prefer-dynamic[Prefers dynamic linking to static linking.]'
"no-integrated-as[Force usage of an external assembler rather than LLVM's integrated one.]"
'no-redzone[disable the use of the redzone]'
- 'relocation-model=[The relocation model to use. (default: pic)]:MODEL:(pic static dynamic-no-pic)'
- 'code-model=[choose the code model to use (llc -code-model for details)]:MODEL:'
- 'metadata=[metadata to mangle symbol names with]:VAL:'
- 'extra-filenames=[extra data to put in each output filename]:VAL:'
- 'codegen-units=[divide crate into N units to optimize in parallel]:N:'
+ 'relocation-model[The relocation model to use. (default: pic)]:MODEL:(pic static dynamic-no-pic)'
+ 'code-model[choose the code model to use (llc -code-model for details)]:MODEL:'
+ 'metadata[metadata to mangle symbol names with]:VAL:'
+ 'extra-filenames[extra data to put in each output filename]:VAL:'
+ 'codegen-units[divide crate into N units to optimize in parallel]:N:'
+ 'remark[print remarks for these optimization passes (space separated, or "all")]:TYPE:'
+ 'debuginfo[debug info emission level, 0 = no debug info, 1 = line tables only, 2 = full debug info with variable and type information]:LEVEL:_values "Debug Levels" "$_rustc_debuginfo_levels[@]"'
+ 'opt-level[Optimize with possible levels 0-3]:LEVEL:(0 1 2 3)'
'help[Show all codegen options]'
)
_rustc_opts_lint=(
'help[Show a list of all lints]'
- 'experimental[detects use of #\[experimental\] items]'
- 'heap-memory[use of any (Box type or @ type) heap memory]'
- 'managed-heap-memory[use of managed (@ type) heap memory]'
- 'missing-doc[detects missing documentation for public members]'
- 'non-uppercase-statics[static constants should have uppercase identifiers]'
- 'owned-heap-memory[use of owned (~ type) heap memory]'
- 'unnecessary-qualification[detects unnecessarily qualified names]'
- 'unsafe-block[usage of an `unsafe` block]'
- 'unstable[detects use of #\[unstable\] items (incl. items with no stability attribute)]'
- 'unused-result[unused result of an expression in a statement]'
- 'variant-size-difference[detects enums with widely varying variant sizes]'
- 'ctypes[proper use of libc types in foreign modules]'
- 'dead-assignment[detect assignments that will never be read]'
- 'dead-code[detect piece of code that will never be used]'
- 'deprecated[detects use of #\[deprecated\] items]'
- 'non-camel-case-types[types, variants and traits should have camel case names]'
- 'non-snake-case[methods, functions, lifetime parameters and modules should have snake case names]'
- 'path-statement[path statements with no effect]'
- 'raw-pointer-deriving[uses of #\[deriving\] with raw pointers are rarely correct]'
- 'type-limits[comparisons made useless by limits of the types involved]'
- 'type-overflow[literal out of range for its type]'
- 'unnecessary-allocation[detects unnecessary allocations that can be eliminated]'
- 'unnecessary-parens[`if`, `match`, `while` and `return` do not need parentheses]'
- 'unreachable-code[detects unreachable code]'
- 'unrecognized-lint[unrecognized lint attribute]'
- 'unsigned-negate[using an unary minus operator on unsigned type]'
- 'unused-attribute[detects attributes that were not used by the compiler]'
- 'unused-imports[imports that are never used]'
- 'unused-must-use[unused result of a type flagged as #\[must_use\]]'
- "unused-mut[detect mut variables which don't need to be mutable]"
- 'unused-unsafe[unnecessary use of an `unsafe` block]'
- 'unused-variable[detect variables which are not used in any way]'
- 'visible-private-types[detect use of private types in exported type signatures]'
- 'warnings[mass-change the level for lints which produce warnings]'
- 'while-true[suggest using `loop { }` instead of `while true { }`]'
- 'unknown-crate-type[unknown crate type found in #\[crate_type\] directive]'
- 'unknown-features[unknown features found in crate-level #\[feature\] directives]'
- 'bad-style[group of non_camel_case_types, non_snake_case, non_uppercase_statics]'
- 'unused[group of unused_imports, unused_variable, dead_assignment, dead_code, unused_mut, unreachable_code]'
+ 'box-pointers[(default: allow) use of owned (Box type) heap memory]'
+ 'experimental[(default: allow) detects use of #\[experimental\] items]'
+ 'fat-ptr-transmutes[(default: allow) detects transmutes of fat pointers]'
+ 'missing-docs[(default: allow) detects missing documentation for public members]'
+ 'unsafe-blocks[(default: allow) usage of an "unsafe" block]'
+ 'unstable[(default: allow) detects use of #\[unstable\] items (incl. items with no stability attribute)]'
+ 'unused-extern-crates[(default: allow) extern crates that are never used]'
+ 'unused-import-braces[(default: allow) unnecessary braces around an imported item]'
+ 'unused-qualifications[(default: allow) detects unnecessarily qualified names]'
+ 'unused-results[(default: allow) unused result of an expression in a statement]'
+ 'unused-typecasts[(default: allow) detects unnecessary type casts that can be removed]'
+ 'variant-size-differences[(default: allow) detects enums with widely varying variant sizes]'
+ 'dead-code[(default: warn) detect unused, unexported items]'
+ 'deprecated[(default: warn) detects use of #\[deprecated\] items]'
+ 'improper-ctypes[(default: warn) proper use of libc types in foreign modules]'
+ 'missing-copy-implementations[(default: warn) detects potentially-forgotten implementations of "Copy"]'
+ 'non-camel-case-types[(default: warn) types, variants, traits and type parameters should have camel case names]'
+ 'non-shorthand-field-patterns[(default: warn) using "Struct { x: x }" instead of "Struct { x }"]'
+ 'non-snake-case[(default: warn) methods, functions, lifetime parameters and modules should have snake case names]'
+ 'non-upper-case-globals[(default: warn) static constants should have uppercase identifiers]'
+ 'overflowing-literals[(default: warn) literal out of range for its type]'
+ 'path-statements[(default: warn) path statements with no effect]'
+ 'raw-pointer-deriving[(default: warn) uses of #\[derive\] with raw pointers are rarely correct]'
+ 'unknown-lints[(default: warn) unrecognized lint attribute]'
+ 'unreachable-code[(default: warn) detects unreachable code paths]'
+ 'unsigned-negation[(default: warn) using an unary minus operator on unsigned type]'
+ 'unused-allocation[(default: warn) detects unnecessary allocations that can be eliminated]'
+ 'unused-assignments[(default: warn) detect assignments that will never be read]'
+ 'unused-attributes[(default: warn) detects attributes that were not used by the compiler]'
+ 'unused-comparisons[(default: warn) comparisons made useless by limits of the types involved]'
+ 'unused-imports[(default: warn) imports that are never used]'
+ 'unused-must-use[(default: warn) unused result of a type flagged as must_use]'
+ "unused-mut[(default: warn) detect mut variables which don't need to be mutable]"
+ 'unused-parens[(default: warn) "if", "match", "while" and "return" do not need parentheses]'
+ 'unused-unsafe[(default: warn) unnecessary use of an "unsafe" block]'
+ 'unused-variables[(default: warn) detect variables which are not used in any way]'
+ 'warnings[(default: warn) mass-change the level for lints which produce warnings]'
+ 'while-true[(default: warn) suggest using "loop { }" instead of "while true { }"]'
+ "exceeding-bitshifts[(default: deny) shift exceeds the type's number of bits]"
+ 'unknown-crate-types[(default: deny) unknown crate type found in #\[crate_type\] directive]'
+ 'unknown-features[(default: deny) unknown features found in crate-level #\[feature\] directives]'
+ 'bad-style[non-camel-case-types, non-snake-case, non-upper-case-globals]'
+ 'unused[unused-imports, unused-variables, unused-assignments, dead-code, unused-mut, unreachable-code, unused-must-use, unused-unsafe, path-statements]'
)
_rustc_opts_debug=(
'show-span[show spans for compiler debugging]'
'count-type-sizes[count the sizes of aggregate types]'
'meta-stats[gather metadata statistics]'
- 'no-opt[do not optimize, even if -O is passed]'
'print-link-args[Print the arguments passed to the linker]'
'gc[Garbage collect shared data (experimental)]'
'print-llvm-passes[Prints the llvm optimization passes being run]'
- 'lto[Perform LLVM link-time optimizations]'
'ast-json[Print the AST as JSON and halt]'
'ast-json-noexpand[Print the pre-expansion AST as JSON and halt]'
'ls[List the symbols defined by a library crate]'
'flowgraph-print-moves[Include move analysis data in --pretty flowgraph output]'
'flowgraph-print-assigns[Include assignment analysis data in --pretty flowgraph output]'
'flowgraph-print-all[Include all dataflow analysis data in --pretty flowgraph output]'
+ 'print-regiion-graph[Prints region inference graph. Use with RUST_REGION_GRAPH=help for more info]'
+ 'parse-only[Parse only; do not compile, assemble, or link]'
+ 'no-trans[Run all passes except translation; no output]'
+ 'no-analysis[Parse and expand the source, but run no analysis]'
+ 'unstable-options[Adds unstable command line options to rustc interface]'
+ 'print-enum-sizes[Print the size of enums and their variants]'
)
_rustc_opts_fun_lint(){
_values 'options' "$_rustc_opts_codegen[@]"
}
+_rustc_opts_fun_link(){
+ _values 'options' "$_rustc_opts_link[@]"
+}
+
_arguments -s : \
'(-W --warn)'{-W,--warn=}'[Set lint warnings]:lint options:_rustc_opts_fun_lint' \
'(-A --allow)'{-A,--allow=}'[Set lint allowed]:lint options:_rustc_opts_fun_lint' \
'(-D --deny)'{-D,--deny=}'[Set lint denied]:lint options:_rustc_opts_fun_lint' \
'(-F --forbid)'{-F,--forbid=}'[Set lint forbidden]:lint options:_rustc_opts_fun_lint' \
'*-Z[Set internal debugging options]:debug options:_rustc_opts_fun_debug' \
- '*-C[Set internal Codegen options]:codegen options:_rustc_opts_fun_codegen' \
+ '(-C --codegen)'{-C,--codegen}'[Set internal Codegen options]:codegen options:_rustc_opts_fun_codegen' \
+ '*-l[Link the generated crates to the specified native library NAME. the optional KIND can be one of, static, dylib, or framework. If omitted, dylib is assumed.]:ARG:_rustc_opts_fun_link' \
"$_rustc_opts_switches[@]" \
"$_rustc_opts_vals[@]" \
'::files:_files -g "*.rs"'
//! let five = five.clone();
//!
//! Thread::spawn(move || {
-//! println!("{}", five);
-//! }).detach();
+//! println!("{:?}", five);
+//! });
//! }
//! ```
//!
//! *number += 1;
//!
//! println!("{}", *number); // prints 6
-//! }).detach();
+//! });
//! }
//! ```
use core::fmt::{self, Show};
use core::cmp::{Eq, Ord, PartialEq, PartialOrd, Ordering};
use core::default::Default;
-use core::kinds::{Sync, Send};
+use core::marker::{Sync, Send};
use core::mem::{min_align_of, size_of, drop};
use core::mem;
use core::nonzero::NonZero;
/// let local_numbers = child_numbers.as_slice();
///
/// // Work with the local numbers
-/// }).detach();
+/// });
/// }
/// }
/// ```
impl<T: fmt::Show> fmt::Show for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- (**self).fmt(f)
+ write!(f, "Arc({:?})", (**self))
}
}
#[test]
fn show_arc() {
let a = Arc::new(5u32);
- assert!(format!("{}", a) == "5")
+ assert!(format!("{:?}", a) == "Arc(5u32)")
}
// Make sure deriving works with Arc<T>
use core::default::Default;
use core::fmt;
use core::hash::{self, Hash};
-use core::kinds::Sized;
+use core::marker::Sized;
use core::mem;
use core::option::Option;
use core::ptr::Unique;
impl<T: ?Sized + fmt::Show> fmt::Show for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- (**self).fmt(f)
+ write!(f, "Box({:?})", &**self)
+ }
+}
+
+impl<T: ?Sized + fmt::String> fmt::String for Box<T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(&**self, f)
}
}
#![no_std]
#![allow(unknown_features)]
-#![feature(lang_items, phase, unsafe_destructor, default_type_params, old_orphan_check)]
-#![feature(associated_types)]
+#![feature(lang_items, unsafe_destructor)]
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate core;
-
-#[cfg(not(stage0))]
#[macro_use]
extern crate core;
-
extern crate libc;
// Allow testing this library
-#[cfg(all(test, stage0))]
-#[phase(plugin, link)]
-extern crate std;
-
-#[cfg(all(test, not(stage0)))]
-#[macro_use]
-extern crate std;
-
-#[cfg(all(test, stage0))]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(all(test, not(stage0)))]
-#[macro_use]
-extern crate log;
+#[cfg(test)] #[macro_use] extern crate std;
+#[cfg(test)] #[macro_use] extern crate log;
// Heaps provided for low-level allocation strategies
use core::default::Default;
use core::fmt;
use core::hash::{self, Hash};
-use core::kinds::marker;
+use core::marker;
use core::mem::{transmute, min_align_of, size_of, forget};
use core::nonzero::NonZero;
use core::ops::{Deref, Drop};
#[experimental = "Show is experimental."]
impl<T: fmt::Show> fmt::Show for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- (**self).fmt(f)
+ write!(f, "Rc({:?})", **self)
}
}
assert!(cow1_weak.upgrade().is_none());
}
+ #[test]
+ fn test_show() {
+ let foo = Rc::new(75u);
+ assert!(format!("{:?}", foo) == "Rc(75u)")
+ }
+
}
/// bv.set(3, true);
/// bv.set(5, true);
/// bv.set(7, true);
-/// println!("{}", bv.to_string());
+/// println!("{:?}", bv);
/// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
///
/// // flip all values in bitvector, producing non-primes less than 10
/// bv.negate();
-/// println!("{}", bv.to_string());
+/// println!("{:?}", bv);
/// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
///
/// // reset bitvector to empty
/// bv.clear();
-/// println!("{}", bv.to_string());
+/// println!("{:?}", bv);
/// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
/// ```
#[stable]
if extra_bytes > 0 {
let mut last_word = 0u32;
- for (i, &byte) in bytes[complete_words*4..].iter().enumerate() {
+ for (i, &byte) in bytes.index(&((complete_words*4)..)).iter().enumerate() {
last_word |= (reverse_bits(byte) as u32) << (i * 8);
}
bitv.storage.push(last_word);
impl fmt::Show for BitvSet {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(fmt, "{{"));
+ try!(write!(fmt, "BitvSet {{"));
let mut first = true;
for n in self.iter() {
if !first {
try!(write!(fmt, ", "));
}
- try!(write!(fmt, "{}", n));
+ try!(write!(fmt, "{:?}", n));
first = false;
}
write!(fmt, "}}")
#[test]
fn test_to_str() {
let zerolen = Bitv::new();
- assert_eq!(zerolen.to_string(), "");
+ assert_eq!(format!("{:?}", zerolen), "");
let eightbits = Bitv::from_elem(8u, false);
- assert_eq!(eightbits.to_string(), "00000000")
+ assert_eq!(format!("{:?}", eightbits), "00000000")
}
#[test]
let mut b = Bitv::from_elem(2, false);
b.set(0, true);
b.set(1, false);
- assert_eq!(b.to_string(), "10");
+ assert_eq!(format!("{:?}", b), "10");
assert!(!b.none() && !b.all());
}
fn test_from_bytes() {
let bitv = Bitv::from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
let str = concat!("10110110", "00000000", "11111111");
- assert_eq!(bitv.to_string(), str);
+ assert_eq!(format!("{:?}", bitv), str);
}
#[test]
fn test_from_bools() {
let bools = vec![true, false, true, true];
let bitv: Bitv = bools.iter().map(|n| *n).collect();
- assert_eq!(bitv.to_string(), "1011");
+ assert_eq!(format!("{:?}", bitv), "1011");
}
#[test]
s.insert(10);
s.insert(50);
s.insert(2);
- assert_eq!("{1, 2, 10, 50}", s.to_string());
+ assert_eq!("BitvSet {1u, 2u, 10u, 50u}", format!("{:?}", s));
}
#[test]
use core::prelude::*;
-use core::borrow::{BorrowFrom, ToOwned};
+use core::borrow::BorrowFrom;
use core::cmp::Ordering;
use core::default::Default;
use core::fmt::Show;
inner: Map<(&'a K, &'a V), &'a V, Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V>
}
-#[stable]
/// A view into a single entry in a map, which may either be vacant or occupied.
-pub enum Entry<'a, Q: ?Sized +'a, K:'a, V:'a> {
+#[unstable = "precise API still under development"]
+pub enum Entry<'a, K:'a, V:'a> {
/// A vacant Entry
- Vacant(VacantEntry<'a, Q, K, V>),
+ Vacant(VacantEntry<'a, K, V>),
/// An occupied Entry
Occupied(OccupiedEntry<'a, K, V>),
}
-#[stable]
/// A vacant Entry.
-pub struct VacantEntry<'a, Q: ?Sized +'a, K:'a, V:'a> {
- key: &'a Q,
+#[unstable = "precise API still under development"]
+pub struct VacantEntry<'a, K:'a, V:'a> {
+ key: K,
stack: stack::SearchStack<'a, K, V, node::handle::Edge, node::handle::Leaf>,
}
-#[stable]
/// An occupied Entry.
+#[unstable = "precise API still under development"]
pub struct OccupiedEntry<'a, K:'a, V:'a> {
stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>,
}
/// boilerplate gets cut out.
mod stack {
use core::prelude::*;
- use core::kinds::marker;
+ use core::marker;
use core::mem;
use core::ops::{Deref, DerefMut};
use super::BTreeMap;
#[stable]
impl<K: Show, V: Show> Show for BTreeMap<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
+ try!(write!(f, "BTreeMap {{"));
for (i, (k, v)) in self.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{}: {}", *k, *v));
+ try!(write!(f, "{:?}: {:?}", *k, *v));
}
write!(f, "}}")
}
impl<K, V, E, T> Iterator for AbsIter<T> where
- T: DoubleEndedIterator + Iterator<Item=TraversalItem<K, V, E>> + Traverse<E>,
+ T: DoubleEndedIterator<Item=TraversalItem<K, V, E>> + Traverse<E>,
{
type Item = (K, V);
}
impl<K, V, E, T> DoubleEndedIterator for AbsIter<T> where
- T: DoubleEndedIterator + Iterator<Item=TraversalItem<K, V, E>> + Traverse<E>,
+ T: DoubleEndedIterator<Item=TraversalItem<K, V, E>> + Traverse<E>,
{
// next_back is totally symmetric to next
fn next_back(&mut self) -> Option<(K, V)> {
#[stable]
impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
-impl<'a, Q: ?Sized, K: Ord, V> Entry<'a, Q, K, V> {
+impl<'a, K: Ord, V> Entry<'a, K, V> {
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
- pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> {
+ pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
match self {
Occupied(entry) => Ok(entry.into_mut()),
Vacant(entry) => Err(entry),
}
}
-impl<'a, Q: ?Sized + ToOwned<K>, K: Ord, V> VacantEntry<'a, Q, K, V> {
- #[stable]
+impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it.
+ #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
pub fn insert(self, value: V) -> &'a mut V {
- self.stack.insert(self.key.to_owned(), value)
+ self.stack.insert(self.key, value)
}
}
impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
- #[stable]
/// Gets a reference to the value in the entry.
+ #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
pub fn get(&self) -> &V {
self.stack.peek()
}
- #[stable]
/// Gets a mutable reference to the value in the entry.
+ #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
pub fn get_mut(&mut self) -> &mut V {
self.stack.peek_mut()
}
- #[stable]
/// Converts the entry into a mutable reference to its value.
+ #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
pub fn into_mut(self) -> &'a mut V {
self.stack.into_top()
}
- #[stable]
/// Sets the value of the entry with the OccupiedEntry's key,
/// and returns the entry's old value.
+ #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
pub fn insert(&mut self, mut value: V) -> V {
mem::swap(self.stack.peek_mut(), &mut value);
value
}
- #[stable]
/// Takes the value of the entry out of the map, and returns it.
+ #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
pub fn remove(self) -> V {
self.stack.remove()
}
///
/// // count the number of occurrences of letters in the vec
/// for x in vec!["a","b","a","c","a","b"].iter() {
- /// match count.entry(x) {
+ /// match count.entry(*x) {
/// Entry::Vacant(view) => {
/// view.insert(1);
/// },
/// assert_eq!(count["a"], 3u);
/// ```
/// The key must have the same ordering before or after `.to_owned()` is called.
- #[stable]
- pub fn entry<'a, Q: ?Sized>(&'a mut self, mut key: &'a Q) -> Entry<'a, Q, K, V>
- where Q: Ord + ToOwned<K>
- {
+ #[unstable = "precise API still under development"]
+ pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> {
// same basic logic of `swap` and `pop`, blended together
let mut stack = stack::PartialSearchStack::new(self);
loop {
let result = stack.with(move |pusher, node| {
- return match Node::search(node, key) {
+ return match Node::search(node, &key) {
Found(handle) => {
// Perfect match
Finished(Occupied(OccupiedEntry {
#[cfg(test)]
mod test {
use prelude::*;
- use std::borrow::{ToOwned, BorrowFrom};
+ use std::borrow::BorrowFrom;
use super::{BTreeMap, Occupied, Vacant};
let mut map: BTreeMap<int, int> = xs.iter().map(|&x| x).collect();
// Existing key (insert)
- match map.entry(&1) {
+ match map.entry(1) {
Vacant(_) => unreachable!(),
Occupied(mut view) => {
assert_eq!(view.get(), &10);
// Existing key (update)
- match map.entry(&2) {
+ match map.entry(2) {
Vacant(_) => unreachable!(),
Occupied(mut view) => {
let v = view.get_mut();
assert_eq!(map.len(), 6);
// Existing key (take)
- match map.entry(&3) {
+ match map.entry(3) {
Vacant(_) => unreachable!(),
Occupied(view) => {
assert_eq!(view.remove(), 30);
// Inexistent key (insert)
- match map.entry(&10) {
+ match map.entry(10) {
Occupied(_) => unreachable!(),
Vacant(view) => {
assert_eq!(*view.insert(1000), 1000);
/// // Now the handle still points at index 75, but on the small node, which has no index 75.
/// flag.set(true);
///
-/// println!("Uninitialized memory: {}", handle.into_kv());
+/// println!("Uninitialized memory: {:?}", handle.into_kv());
/// }
/// ```
#[derive(Copy)]
/// An owning traversal over a node's entries and edges
pub type MoveTraversal<K, V> = AbsTraversal<MoveTraversalImpl<K, V>>;
-
+#[old_impl_check]
impl<K, V, E, Impl: TraversalImpl<K, V, E>> Iterator for AbsTraversal<Impl> {
type Item = TraversalItem<K, V, E>;
}
}
+#[old_impl_check]
impl<K, V, E, Impl: TraversalImpl<K, V, E>> DoubleEndedIterator for AbsTraversal<Impl> {
fn next_back(&mut self) -> Option<TraversalItem<K, V, E>> {
let tail_is_edge = self.tail_is_edge;
#[stable]
impl<T: Show> Show for BTreeSet<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
+ try!(write!(f, "BTreeSet {{"));
for (i, x) in self.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{}", *x));
+ try!(write!(f, "{:?}", *x));
}
write!(f, "}}")
set.insert(1);
set.insert(2);
- let set_str = format!("{}", set);
+ let set_str = format!("{:?}", set);
- assert!(set_str == "{1, 2}");
- assert_eq!(format!("{}", empty), "{}");
+ assert_eq!(set_str, "BTreeSet {1i, 2i}");
+ assert_eq!(format!("{:?}", empty), "BTreeSet {}");
}
}
#[stable]
impl<A: fmt::Show> fmt::Show for DList<A> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "["));
+ try!(write!(f, "DList ["));
for (i, e) in self.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{}", *e));
+ try!(write!(f, "{:?}", *e));
}
write!(f, "]")
#[test]
fn test_send() {
let n = list_from(&[1i,2,3]);
- Thread::spawn(move || {
+ Thread::scoped(move || {
check_links(&n);
let a: &[_] = &[&1,&2,&3];
assert_eq!(a, n.iter().collect::<Vec<&int>>());
#[test]
fn test_show() {
let list: DList<int> = range(0i, 10).collect();
- assert!(list.to_string() == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+ assert_eq!(format!("{:?}", list), "DList [0i, 1i, 2i, 3i, 4i, 5i, 6i, 7i, 8i, 9i]");
let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
.map(|&s| s)
.collect();
- assert!(list.to_string() == "[just, one, test, more]");
+ assert_eq!(format!("{:?}", list), "DList [\"just\", \"one\", \"test\", \"more\"]");
}
#[cfg(test)]
impl<E:CLike+fmt::Show> fmt::Show for EnumSet<E> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(fmt, "{{"));
+ try!(write!(fmt, "EnumSet {{"));
let mut first = true;
for e in self.iter() {
if !first {
try!(write!(fmt, ", "));
}
- try!(write!(fmt, "{}", e));
+ try!(write!(fmt, "{:?}", e));
first = false;
}
write!(fmt, "}}")
#[test]
fn test_show() {
let mut e = EnumSet::new();
- assert_eq!("{}", e.to_string());
+ assert!(format!("{:?}", e) == "EnumSet {}");
e.insert(A);
- assert_eq!("{A}", e.to_string());
+ assert!(format!("{:?}", e) == "EnumSet {A}");
e.insert(C);
- assert_eq!("{A, C}", e.to_string());
+ assert!(format!("{:?}", e) == "EnumSet {A, C}");
}
#[test]
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
-#![feature(macro_rules, default_type_params, phase, globs)]
#![feature(unsafe_destructor, slicing_syntax)]
+#![feature(old_impl_check)]
#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
-#![feature(associated_types)]
#![no_std]
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate core;
-
-#[cfg(not(stage0))]
#[macro_use]
extern crate core;
extern crate alloc;
#[cfg(test)] extern crate test;
-
-#[cfg(all(test, stage0))]
-#[phase(plugin, link)]
-extern crate std;
-
-#[cfg(all(test, not(stage0)))]
-#[macro_use]
-extern crate std;
-
-#[cfg(all(test, stage0))]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(all(test, not(stage0)))]
-#[macro_use]
-extern crate log;
+#[cfg(test)] #[macro_use] extern crate std;
+#[cfg(test)] #[macro_use] extern crate log;
pub use binary_heap::BinaryHeap;
pub use bitv::Bitv;
// Needed for the vec! macro
pub use alloc::boxed;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod macros;
pub mod binary_heap;
pub use core::option; // necessary for panic!()
pub use core::clone; // deriving(Clone)
pub use core::cmp; // deriving(Eq, Ord, etc.)
- pub use core::kinds; // deriving(Copy)
+ #[cfg(stage0)]
+ pub use core::marker as kinds;
+ pub use core::marker; // deriving(Copy)
pub use core::hash; // deriving(Hash)
}
pub use core::iter::{FromIterator, Extend, IteratorExt};
pub use core::iter::{Iterator, DoubleEndedIterator, RandomAccessIterator};
pub use core::iter::{ExactSizeIterator};
- pub use core::kinds::{Copy, Send, Sized, Sync};
+ pub use core::marker::{Copy, Send, Sized, Sync};
pub use core::mem::drop;
pub use core::ops::{Drop, Fn, FnMut, FnOnce};
pub use core::option::Option;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-/// Creates a `std::vec::Vec` containing the arguments.
-// NOTE: remove after the next snapshot
-#[cfg(stage0)]
-macro_rules! vec {
- ($($e:expr),*) => ({
- // leading _ to allow empty construction without a warning.
- let mut _temp = ::vec::Vec::new();
- $(_temp.push($e);)*
- _temp
- });
- ($($e:expr),+,) => (vec!($($e),+))
-}
-
/// Creates a `Vec` containing the arguments.
-#[cfg(not(stage0))]
#[macro_export]
macro_rules! vec {
($($x:expr),*) => ({
use core::default::Default;
use core::fmt;
use core::iter::{self, repeat, FromIterator, RandomAccessIterator};
-use core::kinds::marker;
+use core::marker;
use core::mem;
use core::num::{Int, UnsignedInt};
use core::ops::{Index, IndexMut};
/// *num = *num - 2;
/// }
/// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
- /// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>()[], b);
+ /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut int>>()[], b);
/// ```
#[stable]
pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
let buf = self.buffer_as_slice();
if contiguous {
let (empty, buf) = buf.split_at(0);
- (buf[self.tail..self.head], empty)
+ (buf.index(&(self.tail..self.head)), empty)
} else {
let (mid, right) = buf.split_at(self.tail);
let (left, _) = mid.split_at(self.head);
#[stable]
impl<T: fmt::Show> fmt::Show for RingBuf<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "["));
+ try!(write!(f, "RingBuf ["));
for (i, e) in self.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{}", *e));
+ try!(write!(f, "{:?}", *e));
}
write!(f, "]")
assert_eq!(d.len(), 3u);
d.push_back(137);
assert_eq!(d.len(), 4u);
- debug!("{}", d.front());
assert_eq!(*d.front().unwrap(), 42);
- debug!("{}", d.back());
assert_eq!(*d.back().unwrap(), 137);
let mut i = d.pop_front();
- debug!("{}", i);
assert_eq!(i, Some(42));
i = d.pop_back();
- debug!("{}", i);
assert_eq!(i, Some(137));
i = d.pop_back();
- debug!("{}", i);
assert_eq!(i, Some(137));
i = d.pop_back();
- debug!("{}", i);
assert_eq!(i, Some(17));
assert_eq!(d.len(), 0u);
d.push_back(3);
#[test]
fn test_show() {
let ringbuf: RingBuf<int> = range(0i, 10).collect();
- assert!(format!("{}", ringbuf) == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
+ assert_eq!(format!("{:?}", ringbuf), "RingBuf [0i, 1i, 2i, 3i, 4i, 5i, 6i, 7i, 8i, 9i]");
let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter()
.map(|&s| s)
.collect();
- assert!(format!("{}", ringbuf) == "[just, one, test, more]");
+ assert_eq!(format!("{:?}", ringbuf), "RingBuf [\"just\", \"one\", \"test\", \"more\"]");
}
#[test]
//! #![feature(slicing_syntax)]
//! fn main() {
//! let numbers = [0i, 1i, 2i];
-//! let last_numbers = numbers[1..3];
+//! let last_numbers = numbers.index(&(1..3));
//! // last_numbers is now &[1i, 2i]
//! }
//! ```
use core::cmp::{self, Ord, PartialEq};
use core::iter::{Iterator, IteratorExt};
use core::iter::{range, range_step, MultiplicativeIterator};
-use core::kinds::Sized;
+use core::marker::Sized;
use core::mem::size_of;
use core::mem;
-use core::ops::{FnMut, SliceMut};
+use core::ops::{FnMut, FullRange, Index, IndexMut};
use core::option::Option::{self, Some, None};
use core::ptr::PtrExt;
use core::ptr;
#[unstable = "trait is unstable"]
impl<T> BorrowFrom<Vec<T>> for [T] {
- fn borrow_from(owned: &Vec<T>) -> &[T] { owned[] }
+ fn borrow_from(owned: &Vec<T>) -> &[T] { owned.index(&FullRange) }
}
#[unstable = "trait is unstable"]
impl<T> BorrowFromMut<Vec<T>> for [T] {
- fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { owned.as_mut_slice_() }
+ fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { owned.index_mut(&FullRange) }
}
#[unstable = "trait is unstable"]
#[cfg(test)]
mod tests {
- use prelude::{Some, None, range, Vec, ToString, Clone, Greater, Less, Equal};
- use prelude::{SliceExt, Iterator, IteratorExt};
- use prelude::AsSlice;
- use prelude::{RandomAccessIterator, Ord, SliceConcatExt};
+ use core::cmp::Ordering::{Greater, Less, Equal};
+ use core::prelude::{Some, None, range, Clone};
+ use core::prelude::{Iterator, IteratorExt};
+ use core::prelude::{AsSlice};
+ use core::prelude::{Ord, FullRange};
use core::default::Default;
use core::mem;
+ use core::ops::Index;
+ use std::iter::RandomAccessIterator;
use std::rand::{Rng, thread_rng};
use std::rc::Rc;
- use super::ElementSwaps;
+ use string::ToString;
+ use vec::Vec;
+ use super::{ElementSwaps, SliceConcatExt, SliceExt};
fn square(n: uint) -> uint { n * n }
// Test on stack.
let vec_stack: &[_] = &[1i, 2, 3];
- let v_b = vec_stack[1u..3u].to_vec();
+ let v_b = vec_stack.index(&(1u..3u)).to_vec();
assert_eq!(v_b.len(), 2u);
let v_b = v_b.as_slice();
assert_eq!(v_b[0], 2);
// Test `Box<[T]>`
let vec_unique = vec![1i, 2, 3, 4, 5, 6];
- let v_d = vec_unique[1u..6u].to_vec();
+ let v_d = vec_unique.index(&(1u..6u)).to_vec();
assert_eq!(v_d.len(), 5u);
let v_d = v_d.as_slice();
assert_eq!(v_d[0], 2);
#[test]
fn test_slice_from() {
let vec: &[int] = &[1, 2, 3, 4];
- assert_eq!(vec[0..], vec);
+ assert_eq!(vec.index(&(0..)), vec);
let b: &[int] = &[3, 4];
- assert_eq!(vec[2..], b);
+ assert_eq!(vec.index(&(2..)), b);
let b: &[int] = &[];
- assert_eq!(vec[4..], b);
+ assert_eq!(vec.index(&(4..)), b);
}
#[test]
fn test_slice_to() {
let vec: &[int] = &[1, 2, 3, 4];
- assert_eq!(vec[..4], vec);
+ assert_eq!(vec.index(&(0..4)), vec);
let b: &[int] = &[1, 2];
- assert_eq!(vec[..2], b);
+ assert_eq!(vec.index(&(0..2)), b);
let b: &[int] = &[];
- assert_eq!(vec[..0], b);
+ assert_eq!(vec.index(&(0..0)), b);
}
macro_rules! test_show_vec {
($x:expr, $x_str:expr) => ({
let (x, x_str) = ($x, $x_str);
- assert_eq!(format!("{}", x), x_str);
- assert_eq!(format!("{}", x.as_slice()), x_str);
+ assert_eq!(format!("{:?}", x), x_str);
+ assert_eq!(format!("{:?}", x.as_slice()), x_str);
})
}
let empty: Vec<int> = vec![];
test_show_vec!(empty, "[]");
- test_show_vec!(vec![1i], "[1]");
- test_show_vec!(vec![1i, 2, 3], "[1, 2, 3]");
+ test_show_vec!(vec![1i], "[1i]");
+ test_show_vec!(vec![1i, 2, 3], "[1i, 2i, 3i]");
test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]],
- "[[], [1], [1, 1]]");
+ "[[], [1u], [1u, 1u]]");
let empty_mut: &mut [int] = &mut[];
test_show_vec!(empty_mut, "[]");
let v: &mut[int] = &mut[1];
- test_show_vec!(v, "[1]");
+ test_show_vec!(v, "[1i]");
let v: &mut[int] = &mut[1, 2, 3];
- test_show_vec!(v, "[1, 2, 3]");
+ test_show_vec!(v, "[1i, 2i, 3i]");
let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
- test_show_vec!(v, "[[], [1], [1, 1]]");
+ test_show_vec!(v, "[[], [1u], [1u, 1u]]");
}
#[test]
}
assert_eq!(cnt, 3);
- for f in v[1..3].iter() {
+ for f in v.index(&(1..3)).iter() {
assert!(*f == Foo);
cnt += 1;
}
use core::clone::Clone;
use core::iter::AdditiveIterator;
use core::iter::{range, Iterator, IteratorExt};
-use core::ops;
+use core::ops::{FullRange, Index};
use core::option::Option::{self, Some, None};
use core::slice::AsSlice;
use core::str as core_str;
#[unstable = "trait is unstable"]
impl BorrowFrom<String> for str {
- fn borrow_from(owned: &String) -> &str { owned[] }
+ fn borrow_from(owned: &String) -> &str { owned.index(&FullRange) }
}
#[unstable = "trait is unstable"]
/// Any string that can be represented as a slice.
#[stable]
-pub trait StrExt: ops::Slice<uint, str> {
+pub trait StrExt: Index<FullRange, Output = str> {
/// Escapes each char in `s` with `char::escape_default`.
#[unstable = "return type may change to be an iterator"]
fn escape_default(&self) -> String {
#[unstable = "this functionality may be moved to libunicode"]
fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions {
- iter: self[].chars(),
+ iter: self.index(&FullRange).chars(),
buffer: Vec::new(),
sorted: false,
kind: Canonical
#[unstable = "this functionality may be moved to libunicode"]
fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
Decompositions {
- iter: self[].chars(),
+ iter: self.index(&FullRange).chars(),
buffer: Vec::new(),
sorted: false,
kind: Compatible
/// ```
#[stable]
fn contains(&self, pat: &str) -> bool {
- core_str::StrExt::contains(self[], pat)
+ core_str::StrExt::contains(self.index(&FullRange), pat)
}
/// Returns true if a string contains a char pattern.
/// ```
#[unstable = "might get removed in favour of a more generic contains()"]
fn contains_char<P: CharEq>(&self, pat: P) -> bool {
- core_str::StrExt::contains_char(self[], pat)
+ core_str::StrExt::contains_char(self.index(&FullRange), pat)
}
/// An iterator over the characters of `self`. Note, this iterates
/// ```
#[stable]
fn chars(&self) -> Chars {
- core_str::StrExt::chars(self[])
+ core_str::StrExt::chars(self.index(&FullRange))
}
/// An iterator over the bytes of `self`
/// ```
#[stable]
fn bytes(&self) -> Bytes {
- core_str::StrExt::bytes(self[])
+ core_str::StrExt::bytes(self.index(&FullRange))
}
/// An iterator over the characters of `self` and their byte offsets.
#[stable]
fn char_indices(&self) -> CharIndices {
- core_str::StrExt::char_indices(self[])
+ core_str::StrExt::char_indices(self.index(&FullRange))
}
/// An iterator over substrings of `self`, separated by characters
/// ```
#[stable]
fn split<P: CharEq>(&self, pat: P) -> Split<P> {
- core_str::StrExt::split(self[], pat)
+ core_str::StrExt::split(self.index(&FullRange), pat)
}
/// An iterator over substrings of `self`, separated by characters
/// ```
#[stable]
fn splitn<P: CharEq>(&self, count: uint, pat: P) -> SplitN<P> {
- core_str::StrExt::splitn(self[], count, pat)
+ core_str::StrExt::splitn(self.index(&FullRange), count, pat)
}
/// An iterator over substrings of `self`, separated by characters
/// ```
#[unstable = "might get removed"]
fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> {
- core_str::StrExt::split_terminator(self[], pat)
+ core_str::StrExt::split_terminator(self.index(&FullRange), pat)
}
/// An iterator over substrings of `self`, separated by characters
/// ```
#[stable]
fn rsplitn<P: CharEq>(&self, count: uint, pat: P) -> RSplitN<P> {
- core_str::StrExt::rsplitn(self[], count, pat)
+ core_str::StrExt::rsplitn(self.index(&FullRange), count, pat)
}
/// An iterator over the start and end indices of the disjoint
/// ```
#[unstable = "might have its iterator type changed"]
fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> {
- core_str::StrExt::match_indices(self[], pat)
+ core_str::StrExt::match_indices(self.index(&FullRange), pat)
}
/// An iterator over the substrings of `self` separated by the pattern `sep`.
/// ```
#[unstable = "might get removed in the future in favor of a more generic split()"]
fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> {
- core_str::StrExt::split_str(self[], pat)
+ core_str::StrExt::split_str(self.index(&FullRange), pat)
}
/// An iterator over the lines of a string (subsequences separated
/// ```
#[stable]
fn lines(&self) -> Lines {
- core_str::StrExt::lines(self[])
+ core_str::StrExt::lines(self.index(&FullRange))
}
/// An iterator over the lines of a string, separated by either
/// ```
#[stable]
fn lines_any(&self) -> LinesAny {
- core_str::StrExt::lines_any(self[])
+ core_str::StrExt::lines_any(self.index(&FullRange))
}
/// Returns a slice of the given string from the byte range
/// ```
#[unstable = "use slice notation [a..b] instead"]
fn slice(&self, begin: uint, end: uint) -> &str {
- core_str::StrExt::slice(self[], begin, end)
+ core_str::StrExt::slice(self.index(&FullRange), begin, end)
}
/// Returns a slice of the string from `begin` to its end.
/// See also `slice`, `slice_to` and `slice_chars`.
#[unstable = "use slice notation [a..] instead"]
fn slice_from(&self, begin: uint) -> &str {
- core_str::StrExt::slice_from(self[], begin)
+ core_str::StrExt::slice_from(self.index(&FullRange), begin)
}
/// Returns a slice of the string from the beginning to byte
/// See also `slice`, `slice_from` and `slice_chars`.
#[unstable = "use slice notation [0..a] instead"]
fn slice_to(&self, end: uint) -> &str {
- core_str::StrExt::slice_to(self[], end)
+ core_str::StrExt::slice_to(self.index(&FullRange), end)
}
/// Returns a slice of the string from the character range
/// ```
#[unstable = "may have yet to prove its worth"]
fn slice_chars(&self, begin: uint, end: uint) -> &str {
- core_str::StrExt::slice_chars(self[], begin, end)
+ core_str::StrExt::slice_chars(self.index(&FullRange), begin, end)
}
/// Takes a bytewise (not UTF-8) slice from a string.
/// the entire slice as well.
#[stable]
unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str {
- core_str::StrExt::slice_unchecked(self[], begin, end)
+ core_str::StrExt::slice_unchecked(self.index(&FullRange), begin, end)
}
/// Returns true if the pattern `pat` is a prefix of the string.
/// ```
#[stable]
fn starts_with(&self, pat: &str) -> bool {
- core_str::StrExt::starts_with(self[], pat)
+ core_str::StrExt::starts_with(self.index(&FullRange), pat)
}
/// Returns true if the pattern `pat` is a suffix of the string.
/// ```
#[stable]
fn ends_with(&self, pat: &str) -> bool {
- core_str::StrExt::ends_with(self[], pat)
+ core_str::StrExt::ends_with(self.index(&FullRange), pat)
}
/// Returns a string with all pre- and suffixes that match
/// ```
#[stable]
fn trim_matches<P: CharEq>(&self, pat: P) -> &str {
- core_str::StrExt::trim_matches(self[], pat)
+ core_str::StrExt::trim_matches(self.index(&FullRange), pat)
}
/// Returns a string with all prefixes that match
/// ```
#[stable]
fn trim_left_matches<P: CharEq>(&self, pat: P) -> &str {
- core_str::StrExt::trim_left_matches(self[], pat)
+ core_str::StrExt::trim_left_matches(self.index(&FullRange), pat)
}
/// Returns a string with all suffixes that match
/// ```
#[stable]
fn trim_right_matches<P: CharEq>(&self, pat: P) -> &str {
- core_str::StrExt::trim_right_matches(self[], pat)
+ core_str::StrExt::trim_right_matches(self.index(&FullRange), pat)
}
/// Check that `index`-th byte lies at the start and/or end of a
/// ```
#[unstable = "naming is uncertain with container conventions"]
fn is_char_boundary(&self, index: uint) -> bool {
- core_str::StrExt::is_char_boundary(self[], index)
+ core_str::StrExt::is_char_boundary(self.index(&FullRange), index)
}
/// Pluck a character out of a string and return the index of the next
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
fn char_range_at(&self, start: uint) -> CharRange {
- core_str::StrExt::char_range_at(self[], start)
+ core_str::StrExt::char_range_at(self.index(&FullRange), start)
}
/// Given a byte position and a str, return the previous char and its position.
/// If `i` is not an index following a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
fn char_range_at_reverse(&self, start: uint) -> CharRange {
- core_str::StrExt::char_range_at_reverse(self[], start)
+ core_str::StrExt::char_range_at_reverse(self.index(&FullRange), start)
}
/// Plucks the character starting at the `i`th byte of a string.
/// If `i` is not the index of the beginning of a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
fn char_at(&self, i: uint) -> char {
- core_str::StrExt::char_at(self[], i)
+ core_str::StrExt::char_at(self.index(&FullRange), i)
}
/// Plucks the character ending at the `i`th byte of a string.
/// If `i` is not an index following a valid UTF-8 character.
#[unstable = "naming is uncertain with container conventions"]
fn char_at_reverse(&self, i: uint) -> char {
- core_str::StrExt::char_at_reverse(self[], i)
+ core_str::StrExt::char_at_reverse(self.index(&FullRange), i)
}
/// Work with the byte buffer of a string as a byte slice.
/// ```
#[stable]
fn as_bytes(&self) -> &[u8] {
- core_str::StrExt::as_bytes(self[])
+ core_str::StrExt::as_bytes(self.index(&FullRange))
}
/// Returns the byte index of the first character of `self` that
/// ```
#[stable]
fn find<P: CharEq>(&self, pat: P) -> Option<uint> {
- core_str::StrExt::find(self[], pat)
+ core_str::StrExt::find(self.index(&FullRange), pat)
}
/// Returns the byte index of the last character of `self` that
/// ```
#[stable]
fn rfind<P: CharEq>(&self, pat: P) -> Option<uint> {
- core_str::StrExt::rfind(self[], pat)
+ core_str::StrExt::rfind(self.index(&FullRange), pat)
}
/// Returns the byte index of the first matching substring
/// ```
#[unstable = "might get removed in favor of a more generic find in the future"]
fn find_str(&self, needle: &str) -> Option<uint> {
- core_str::StrExt::find_str(self[], needle)
+ core_str::StrExt::find_str(self.index(&FullRange), needle)
}
/// Retrieves the first character from a string slice and returns
/// ```
#[unstable = "awaiting conventions about shifting and slices"]
fn slice_shift_char(&self) -> Option<(char, &str)> {
- core_str::StrExt::slice_shift_char(self[])
+ core_str::StrExt::slice_shift_char(self.index(&FullRange))
}
/// Returns the byte offset of an inner slice relative to an enclosing outer slice.
/// ```
#[unstable = "awaiting convention about comparability of arbitrary slices"]
fn subslice_offset(&self, inner: &str) -> uint {
- core_str::StrExt::subslice_offset(self[], inner)
+ core_str::StrExt::subslice_offset(self.index(&FullRange), inner)
}
/// Return an unsafe pointer to the strings buffer.
#[stable]
#[inline]
fn as_ptr(&self) -> *const u8 {
- core_str::StrExt::as_ptr(self[])
+ core_str::StrExt::as_ptr(self.index(&FullRange))
}
/// Return an iterator of `u16` over the string encoded as UTF-16.
#[unstable = "this functionality may only be provided by libunicode"]
fn utf16_units(&self) -> Utf16Units {
- Utf16Units { encoder: Utf16Encoder::new(self[].chars()) }
+ Utf16Units { encoder: Utf16Encoder::new(self.index(&FullRange).chars()) }
}
/// Return the number of bytes in this string
#[stable]
#[inline]
fn len(&self) -> uint {
- core_str::StrExt::len(self[])
+ core_str::StrExt::len(self.index(&FullRange))
}
/// Returns true if this slice contains no bytes
#[inline]
#[stable]
fn is_empty(&self) -> bool {
- core_str::StrExt::is_empty(self[])
+ core_str::StrExt::is_empty(self.index(&FullRange))
}
/// Parse this string into the specified type.
#[inline]
#[unstable = "this method was just created"]
fn parse<F: FromStr>(&self) -> Option<F> {
- core_str::StrExt::parse(self[])
+ core_str::StrExt::parse(self.index(&FullRange))
}
/// Returns an iterator over the
/// ```
#[unstable = "this functionality may only be provided by libunicode"]
fn graphemes(&self, is_extended: bool) -> Graphemes {
- UnicodeStr::graphemes(self[], is_extended)
+ UnicodeStr::graphemes(self.index(&FullRange), is_extended)
}
/// Returns an iterator over the grapheme clusters of self and their byte offsets.
/// ```
#[unstable = "this functionality may only be provided by libunicode"]
fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices {
- UnicodeStr::grapheme_indices(self[], is_extended)
+ UnicodeStr::grapheme_indices(self.index(&FullRange), is_extended)
}
/// An iterator over the words of a string (subsequences separated
/// ```
#[stable]
fn words(&self) -> Words {
- UnicodeStr::words(self[])
+ UnicodeStr::words(self.index(&FullRange))
}
/// Returns a string's displayed width in columns, treating control
/// `is_cjk` = `false`) if the locale is unknown.
#[unstable = "this functionality may only be provided by libunicode"]
fn width(&self, is_cjk: bool) -> uint {
- UnicodeStr::width(self[], is_cjk)
+ UnicodeStr::width(self.index(&FullRange), is_cjk)
}
/// Returns a string with leading and trailing whitespace removed.
#[stable]
fn trim(&self) -> &str {
- UnicodeStr::trim(self[])
+ UnicodeStr::trim(self.index(&FullRange))
}
/// Returns a string with leading whitespace removed.
#[stable]
fn trim_left(&self) -> &str {
- UnicodeStr::trim_left(self[])
+ UnicodeStr::trim_left(self.index(&FullRange))
}
/// Returns a string with trailing whitespace removed.
#[stable]
fn trim_right(&self) -> &str {
- UnicodeStr::trim_right(self[])
+ UnicodeStr::trim_right(self.index(&FullRange))
}
}
let mut bytes = [0u8; 4];
for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
let len = c.encode_utf8(&mut bytes).unwrap_or(0);
- let s = ::core::str::from_utf8(bytes[..len]).unwrap();
+ let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
if Some(c) != s.chars().next() {
panic!("character {:x}={} does not decode correctly", c as u32, c);
}
let mut bytes = [0u8; 4];
for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
let len = c.encode_utf8(&mut bytes).unwrap_or(0);
- let s = ::core::str::from_utf8(bytes[..len]).unwrap();
+ let s = ::core::str::from_utf8(&bytes[..len]).unwrap();
if Some(c) != s.chars().rev().next() {
panic!("character {:x}={} does not decode correctly", c as u32, c);
}
use core::hash;
use core::iter::FromIterator;
use core::mem;
-use core::ops::{self, Deref, Add};
+use core::ops::{self, Deref, Add, Index};
use core::ptr;
use core::raw::Slice as RawSlice;
use unicode::str as unicode_str;
if i > 0 {
unsafe {
- res.as_mut_vec().push_all(v[..i])
+ res.as_mut_vec().push_all(v.index(&(0..i)))
};
}
macro_rules! error { () => ({
unsafe {
if subseqidx != i_ {
- res.as_mut_vec().push_all(v[subseqidx..i_]);
+ res.as_mut_vec().push_all(v.index(&(subseqidx..i_)));
}
subseqidx = i;
res.as_mut_vec().push_all(REPLACEMENT);
}
if subseqidx < total {
unsafe {
- res.as_mut_vec().push_all(v[subseqidx..total])
+ res.as_mut_vec().push_all(v.index(&(subseqidx..total)))
};
}
Cow::Owned(res)
impl fmt::Show for FromUtf8Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.error.fmt(f)
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for FromUtf8Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(&self.error, f)
}
}
impl fmt::Show for FromUtf16Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- "invalid utf-16: lone surrogate found".fmt(f)
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for FromUtf16Error {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt("invalid utf-16: lone surrogate found", f)
}
}
}
}
-#[experimental = "waiting on Show stabilization"]
+#[experimental = "waiting on fmt stabilization"]
+impl fmt::String for String {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(&**self, f)
+ }
+}
+
+#[experimental = "waiting on fmt stabilization"]
impl fmt::Show for String {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- (**self).fmt(f)
+ fmt::Show::fmt(&**self, f)
}
}
}
}
-impl ops::Slice<uint, str> for String {
+impl ops::Index<ops::Range<uint>> for String {
+ type Output = str;
#[inline]
- fn as_slice_<'a>(&'a self) -> &'a str {
- unsafe { mem::transmute(self.vec.as_slice()) }
+ fn index(&self, index: &ops::Range<uint>) -> &str {
+ &self.index(&FullRange)[*index]
}
-
+}
+impl ops::Index<ops::RangeTo<uint>> for String {
+ type Output = str;
#[inline]
- fn slice_from_or_fail<'a>(&'a self, from: &uint) -> &'a str {
- self[][*from..]
+ fn index(&self, index: &ops::RangeTo<uint>) -> &str {
+ &self.index(&FullRange)[*index]
}
-
+}
+impl ops::Index<ops::RangeFrom<uint>> for String {
+ type Output = str;
#[inline]
- fn slice_to_or_fail<'a>(&'a self, to: &uint) -> &'a str {
- self[][..*to]
+ fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
+ &self.index(&FullRange)[*index]
}
-
+}
+impl ops::Index<ops::FullRange> for String {
+ type Output = str;
#[inline]
- fn slice_or_fail<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
- self[][*from..*to]
+ fn index(&self, _index: &ops::FullRange) -> &str {
+ unsafe { mem::transmute(self.vec.as_slice()) }
}
}
type Target = str;
fn deref<'a>(&'a self) -> &'a str {
- unsafe { mem::transmute(self.vec[]) }
+ unsafe { mem::transmute(self.vec.index(&FullRange)) }
}
}
fn to_string(&self) -> String;
}
+#[cfg(stage0)]
impl<T: fmt::Show> ToString for T {
fn to_string(&self) -> String {
use core::fmt::Writer;
}
}
+#[cfg(not(stage0))]
+impl<T: fmt::String> ToString for T {
+ fn to_string(&self) -> String {
+ use core::fmt::Writer;
+ let mut buf = String::new();
+ let _ = buf.write_fmt(format_args!("{}", self));
+ buf.shrink_to_fit();
+ buf
+ }
+}
+
impl IntoCow<'static, String, str> for String {
fn into_cow(self) -> CowString<'static> {
Cow::Owned(self)
use str::Utf8Error;
use core::iter::repeat;
use super::{as_string, CowString};
+ use core::ops::FullRange;
#[test]
fn test_as_string() {
#[test]
fn test_slicing() {
let s = "foobar".to_string();
- assert_eq!("foobar", s[]);
- assert_eq!("foo", s[..3]);
- assert_eq!("bar", s[3..]);
- assert_eq!("oob", s[1..4]);
+ assert_eq!("foobar", &s[]);
+ assert_eq!("foo", &s[..3]);
+ assert_eq!("bar", &s[3..]);
+ assert_eq!("oob", &s[1..4]);
}
#[test]
use core::fmt;
use core::hash::{self, Hash};
use core::iter::{repeat, FromIterator};
-use core::kinds::marker::{ContravariantLifetime, InvariantType};
+use core::marker::{ContravariantLifetime, InvariantType};
use core::mem;
use core::nonzero::NonZero;
use core::num::{Int, UnsignedInt};
// self.len <= other.len due to the truncate above, so the
// slice here is always in-bounds.
- let slice = other[self.len()..];
+ let slice = other.index(&(self.len()..));
self.push_all(slice);
}
}
}
}
-impl<T> ops::Slice<uint, [T]> for Vec<T> {
+
+impl<T> ops::Index<ops::Range<uint>> for Vec<T> {
+ type Output = [T];
#[inline]
- fn as_slice_<'a>(&'a self) -> &'a [T] {
- self.as_slice()
+ fn index(&self, index: &ops::Range<uint>) -> &[T] {
+ self.as_slice().index(index)
}
-
+}
+impl<T> ops::Index<ops::RangeTo<uint>> for Vec<T> {
+ type Output = [T];
#[inline]
- fn slice_from_or_fail<'a>(&'a self, start: &uint) -> &'a [T] {
- self.as_slice().slice_from_or_fail(start)
+ fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
+ self.as_slice().index(index)
}
-
+}
+impl<T> ops::Index<ops::RangeFrom<uint>> for Vec<T> {
+ type Output = [T];
#[inline]
- fn slice_to_or_fail<'a>(&'a self, end: &uint) -> &'a [T] {
- self.as_slice().slice_to_or_fail(end)
+ fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
+ self.as_slice().index(index)
}
+}
+impl<T> ops::Index<ops::FullRange> for Vec<T> {
+ type Output = [T];
#[inline]
- fn slice_or_fail<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] {
- self.as_slice().slice_or_fail(start, end)
+ fn index(&self, _index: &ops::FullRange) -> &[T] {
+ self.as_slice()
}
}
-impl<T> ops::SliceMut<uint, [T]> for Vec<T> {
+impl<T> ops::IndexMut<ops::Range<uint>> for Vec<T> {
+ type Output = [T];
#[inline]
- fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] {
- self.as_mut_slice()
+ fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
+ self.as_mut_slice().index_mut(index)
}
-
+}
+impl<T> ops::IndexMut<ops::RangeTo<uint>> for Vec<T> {
+ type Output = [T];
#[inline]
- fn slice_from_or_fail_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] {
- self.as_mut_slice().slice_from_or_fail_mut(start)
+ fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
+ self.as_mut_slice().index_mut(index)
}
-
+}
+impl<T> ops::IndexMut<ops::RangeFrom<uint>> for Vec<T> {
+ type Output = [T];
#[inline]
- fn slice_to_or_fail_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] {
- self.as_mut_slice().slice_to_or_fail_mut(end)
+ fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
+ self.as_mut_slice().index_mut(index)
}
+}
+impl<T> ops::IndexMut<ops::FullRange> for Vec<T> {
+ type Output = [T];
#[inline]
- fn slice_or_fail_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] {
- self.as_mut_slice().slice_or_fail_mut(start, end)
+ fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {
+ self.as_mut_slice()
}
}
+
#[stable]
impl<T> ops::Deref for Vec<T> {
type Target = [T];
}
#[experimental = "waiting on Show stability"]
-impl<T:fmt::Show> fmt::Show for Vec<T> {
+impl<T: fmt::Show> fmt::Show for Vec<T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::Show::fmt(self.as_slice(), f)
+ }
+}
+
+#[cfg(stage0)]
+#[experimental = "waiting on Show stability"]
+impl<T: fmt::Show> fmt::String for Vec<T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self.as_slice(), f)
+ }
+}
+
+#[cfg(not(stage0))]
+#[experimental = "waiting on Show stability"]
+impl<T: fmt::String> fmt::String for Vec<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.as_slice().fmt(f)
+ fmt::String::fmt(self.as_slice(), f)
}
}
use prelude::*;
use core::mem::size_of;
use core::iter::repeat;
+ use core::ops::FullRange;
use test::Bencher;
use super::as_vec;
let (left, right) = values.split_at_mut(2);
{
let left: &[_] = left;
- assert!(left[0..left.len()] == [1, 2][]);
+ assert!(&left[..left.len()] == &[1, 2][]);
}
for p in left.iter_mut() {
*p += 1;
{
let right: &[_] = right;
- assert!(right[0..right.len()] == [3, 4, 5][]);
+ assert!(&right[..right.len()] == &[3, 4, 5][]);
}
for p in right.iter_mut() {
*p += 2;
#[should_fail]
fn test_slice_out_of_bounds_1() {
let x: Vec<int> = vec![1, 2, 3, 4, 5];
- x[-1..];
+ &x[(-1)..];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_2() {
let x: Vec<int> = vec![1, 2, 3, 4, 5];
- x[..6];
+ &x[..6];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_3() {
let x: Vec<int> = vec![1, 2, 3, 4, 5];
- x[-1..4];
+ &x[(-1)..4];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_4() {
let x: Vec<int> = vec![1, 2, 3, 4, 5];
- x[1..6];
+ &x[1..6];
}
#[test]
#[should_fail]
fn test_slice_out_of_bounds_5() {
let x: Vec<int> = vec![1, 2, 3, 4, 5];
- x[3..2];
+ &x[3..2];
}
#[test]
b.bytes = src_len as u64;
b.iter(|| {
- let dst = src.clone().as_slice().to_vec();
+ let dst = src.clone()[].to_vec();
assert_eq!(dst.len(), src_len);
assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
});
if *key >= self.v.len() {
return None;
}
- self.v[*key].take()
+ let result = &mut self.v[*key];
+ result.take()
}
}
#[stable]
impl<V: fmt::Show> fmt::Show for VecMap<V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
+ try!(write!(f, "VecMap {{"));
for (i, (k, v)) in self.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{}: {}", k, *v));
+ try!(write!(f, "{}: {:?}", k, *v));
}
write!(f, "}}")
map.insert(1, 2i);
map.insert(3, 4i);
- let map_str = map.to_string();
- assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}");
- assert_eq!(format!("{}", empty), "{}");
+ let map_str = format!("{:?}", map);
+ assert!(map_str == "VecMap {1: 2i, 3: 4i}" || map_str == "{3: 4i, 1: 2i}");
+ assert_eq!(format!("{:?}", empty), "VecMap {}");
}
#[test]
//! println!("String ({}): {}", as_string.len(), as_string);
//! }
//! None => {
-//! println!("{}", value);
+//! println!("{:?}", value);
//! }
//! }
//! }
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
use fmt;
-use kinds::Copy;
-use ops::Deref;
+use marker::Copy;
+use ops::{Deref, FullRange, Index};
use option::Option;
// macro for implementing n-ary tuple functions and operations
#[unstable = "waiting for Show to stabilize"]
impl<T:fmt::Show> fmt::Show for [T; $N] {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Show::fmt(&self[], f)
+ fmt::Show::fmt(&self.index(&FullRange), f)
}
}
impl<A, B> PartialEq<[B; $N]> for [A; $N] where A: PartialEq<B> {
#[inline]
fn eq(&self, other: &[B; $N]) -> bool {
- self[] == other[]
+ self.index(&FullRange) == other.index(&FullRange)
}
#[inline]
fn ne(&self, other: &[B; $N]) -> bool {
- self[] != other[]
+ self.index(&FullRange) != other.index(&FullRange)
}
}
Rhs: Deref<Target=[B]>,
{
#[inline(always)]
- fn eq(&self, other: &Rhs) -> bool { PartialEq::eq(self[], &**other) }
+ fn eq(&self, other: &Rhs) -> bool {
+ PartialEq::eq(self.index(&FullRange), &**other)
+ }
#[inline(always)]
- fn ne(&self, other: &Rhs) -> bool { PartialEq::ne(self[], &**other) }
+ fn ne(&self, other: &Rhs) -> bool {
+ PartialEq::ne(self.index(&FullRange), &**other)
+ }
}
#[stable]
Lhs: Deref<Target=[A]>
{
#[inline(always)]
- fn eq(&self, other: &[B; $N]) -> bool { PartialEq::eq(&**self, other[]) }
+ fn eq(&self, other: &[B; $N]) -> bool {
+ PartialEq::eq(&**self, other.index(&FullRange))
+ }
#[inline(always)]
- fn ne(&self, other: &[B; $N]) -> bool { PartialEq::ne(&**self, other[]) }
+ fn ne(&self, other: &[B; $N]) -> bool {
+ PartialEq::ne(&**self, other.index(&FullRange))
+ }
}
#[stable]
impl<T:PartialOrd> PartialOrd for [T; $N] {
#[inline]
fn partial_cmp(&self, other: &[T; $N]) -> Option<Ordering> {
- PartialOrd::partial_cmp(&self[], &other[])
+ PartialOrd::partial_cmp(&self.index(&FullRange), &other.index(&FullRange))
}
#[inline]
fn lt(&self, other: &[T; $N]) -> bool {
- PartialOrd::lt(&self[], &other[])
+ PartialOrd::lt(&self.index(&FullRange), &other.index(&FullRange))
}
#[inline]
fn le(&self, other: &[T; $N]) -> bool {
- PartialOrd::le(&self[], &other[])
+ PartialOrd::le(&self.index(&FullRange), &other.index(&FullRange))
}
#[inline]
fn ge(&self, other: &[T; $N]) -> bool {
- PartialOrd::ge(&self[], &other[])
+ PartialOrd::ge(&self.index(&FullRange), &other.index(&FullRange))
}
#[inline]
fn gt(&self, other: &[T; $N]) -> bool {
- PartialOrd::gt(&self[], &other[])
+ PartialOrd::gt(&self.index(&FullRange), &other.index(&FullRange))
}
}
impl<T:Ord> Ord for [T; $N] {
#[inline]
fn cmp(&self, other: &[T; $N]) -> Ordering {
- Ord::cmp(&self[], &other[])
+ Ord::cmp(&self.index(&FullRange), &other.index(&FullRange))
}
}
)+
//! let spinlock_clone = spinlock.clone();
//! Thread::spawn(move|| {
//! spinlock_clone.store(0, Ordering::SeqCst);
-//! }).detach();
+//! });
//!
//! // Wait for the other task to release the lock
//! while spinlock.load(Ordering::SeqCst) != 0 {}
use self::Ordering::*;
-use kinds::Sync;
+use marker::Sync;
use intrinsics;
use cell::UnsafeCell;
use clone::Clone;
use cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
use fmt;
-use kinds::Sized;
+use marker::Sized;
use ops::Deref;
use option::Option;
use self::Cow::*;
/// }
/// }
/// ```
+//#[deriving(Show)] NOTE(stage0): uncomment after snapshot
pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
/// Borrowed data.
Borrowed(&'a B),
Owned(T)
}
+//NOTE(stage0): replace with deriving(Show) after snapshot
+impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where
+ B: fmt::String + ToOwned<T>,
+ T: fmt::String
+{
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
#[stable]
impl<'a, T, B: ?Sized> Clone for Cow<'a, T, B> where B: ToOwned<T> {
fn clone(&self) -> Cow<'a, T, B> {
}
}
-impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where B: fmt::Show + ToOwned<T>, T: fmt::Show {
+impl<'a, T, B: ?Sized> fmt::String for Cow<'a, T, B> where
+ B: fmt::String + ToOwned<T>,
+ T: fmt::String,
+{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
- Borrowed(ref b) => fmt::Show::fmt(b, f),
- Owned(ref o) => fmt::Show::fmt(o, f),
+ Borrowed(ref b) => fmt::String::fmt(b, f),
+ Owned(ref o) => fmt::String::fmt(o, f),
}
}
}
use clone::Clone;
use cmp::PartialEq;
use default::Default;
-use fmt;
-use kinds::{Copy, Send};
+use marker::{Copy, Send};
use ops::{Deref, DerefMut, Drop};
use option::Option;
use option::Option::{None, Some};
}
}
-#[unstable]
-impl<T:fmt::Show> fmt::Show for RefCell<T> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match self.try_borrow() {
- Some(val) => write!(f, "{}", val),
- None => write!(f, "<borrowed RefCell>")
- }
- }
-}
-
struct BorrowRef<'b> {
_borrow: &'b Cell<BorrowFlag>,
}
///
/// ```rust
/// use std::cell::UnsafeCell;
-/// use std::kinds::marker;
+/// use std::marker;
///
/// struct NotThreadSafe<T> {
/// value: UnsafeCell<T>,
#![stable]
-use kinds::Sized;
+use marker::Sized;
/// A common trait for cloning an object.
#[stable]
use self::Ordering::*;
-use kinds::Sized;
+use marker::Sized;
use option::Option::{self, Some, None};
/// Trait for equality comparisons which are [partial equivalence relations](
mod impls {
use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering};
use cmp::Ordering::{Less, Greater, Equal};
- use kinds::Sized;
+ use marker::Sized;
use option::Option;
use option::Option::{Some, None};
use iter::{IteratorExt, range};
use num::{cast, Float, ToPrimitive};
use num::FpCategory as Fp;
-use ops::FnOnce;
+use ops::{FnOnce, Index};
use result::Result::Ok;
use slice::{self, SliceExt};
use str::{self, StrExt};
}
}
- f(unsafe { str::from_utf8_unchecked(buf[..end]) })
+ f(unsafe { str::from_utf8_unchecked(buf.index(&(0..end))) })
}
#![allow(unused_variables)]
use any;
-use cell::{Cell, Ref, RefMut};
+use cell::{Cell, RefCell, Ref, RefMut};
+use char::CharExt;
use iter::{Iterator, IteratorExt, range};
-use kinds::{Copy, Sized};
+use marker::{Copy, Sized};
use mem;
use option::Option;
use option::Option::{Some, None};
-use ops::{Deref, FnOnce};
use result::Result::Ok;
+use ops::{Deref, FnOnce, Index};
use result;
use slice::SliceExt;
use slice;
use str::{self, StrExt, Utf8Error};
-// NOTE: for old macros; remove after the next snapshot
-#[cfg(stage0)] use result::Result::Err;
-
pub use self::num::radix;
pub use self::num::Radix;
pub use self::num::RadixFmt;
}
impl<'a> Show for Arguments<'a> {
+ fn fmt(&self, fmt: &mut Formatter) -> Result {
+ String::fmt(self, fmt)
+ }
+}
+
+impl<'a> String for Arguments<'a> {
fn fmt(&self, fmt: &mut Formatter) -> Result {
write(fmt.buf, *self)
}
}
-/// When a format is not otherwise specified, types are formatted by ascribing
-/// to this trait. There is not an explicit way of selecting this trait to be
-/// used for formatting, it is only if no other format is specified.
+/// Format trait for the `:?` format. Useful for debugging, most all types
+/// should implement this.
#[unstable = "I/O and core have yet to be reconciled"]
pub trait Show {
/// Formats the value using the given formatter.
fn fmt(&self, &mut Formatter) -> Result;
}
+/// When a value can be semantically expressed as a String, this trait may be
+/// used. It corresponds to the default format, `{}`.
+#[unstable = "I/O and core have yet to be reconciled"]
+pub trait String {
+ /// Formats the value using the given formatter.
+ fn fmt(&self, &mut Formatter) -> Result;
+}
+
/// Format trait for the `o` character
#[unstable = "I/O and core have yet to be reconciled"]
for c in sign.into_iter() {
let mut b = [0; 4];
let n = c.encode_utf8(&mut b).unwrap_or(0);
- let b = unsafe { str::from_utf8_unchecked(b[0..n]) };
+ let b = unsafe { str::from_utf8_unchecked(b.index(&(0..n))) };
try!(f.buf.write_str(b));
}
if prefixed { f.buf.write_str(prefix) }
let mut fill = [0u8; 4];
let len = self.fill.encode_utf8(&mut fill).unwrap_or(0);
- let fill = unsafe { str::from_utf8_unchecked(fill[..len]) };
+ let fill = unsafe { str::from_utf8_unchecked(fill.index(&(..len))) };
for _ in range(0, pre_pad) {
try!(self.buf.write_str(fill));
impl Show for Error {
fn fmt(&self, f: &mut Formatter) -> Result {
- "an error occurred when formatting an argument".fmt(f)
+ String::fmt("an error occurred when formatting an argument", f)
}
}
// Implementations of the core formatting traits
-impl<'a, T: ?Sized + Show> Show for &'a T {
- fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) }
-}
-impl<'a, T: ?Sized + Show> Show for &'a mut T {
- fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) }
+macro_rules! fmt_refs {
+ ($($tr:ident),*) => {
+ $(
+ impl<'a, T: ?Sized + $tr> $tr for &'a T {
+ fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) }
+ }
+ impl<'a, T: ?Sized + $tr> $tr for &'a mut T {
+ fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) }
+ }
+ )*
+ }
}
+fmt_refs! { Show, String, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp }
+
impl Show for bool {
fn fmt(&self, f: &mut Formatter) -> Result {
- Show::fmt(if *self { "true" } else { "false" }, f)
+ String::fmt(self, f)
+ }
+}
+
+impl String for bool {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ String::fmt(if *self { "true" } else { "false" }, f)
+ }
+}
+
+#[cfg(stage0)]
+//NOTE(stage0): remove impl after snapshot
+impl Show for str {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ String::fmt(self, f)
}
}
+#[cfg(not(stage0))]
+//NOTE(stage0): remove cfg after snapshot
impl Show for str {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ try!(write!(f, "\""));
+ for c in self.chars().flat_map(|c| c.escape_default()) {
+ try!(write!(f, "{}", c));
+ }
+ write!(f, "\"")
+ }
+}
+
+impl String for str {
fn fmt(&self, f: &mut Formatter) -> Result {
f.pad(self)
}
}
+#[cfg(stage0)]
+//NOTE(stage0): remove impl after snapshot
+impl Show for char {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ String::fmt(self, f)
+ }
+}
+
+#[cfg(not(stage0))]
+//NOTE(stage0): remove cfg after snapshot
impl Show for char {
fn fmt(&self, f: &mut Formatter) -> Result {
use char::CharExt;
+ try!(write!(f, "'"));
+ for c in self.escape_default() {
+ try!(write!(f, "{}", c));
+ }
+ write!(f, "'")
+ }
+}
+impl String for char {
+ fn fmt(&self, f: &mut Formatter) -> Result {
let mut utf8 = [0u8; 4];
let amt = self.encode_utf8(&mut utf8).unwrap_or(0);
- let s: &str = unsafe { mem::transmute(utf8[..amt]) };
- Show::fmt(s, f)
+ let s: &str = unsafe { mem::transmute(utf8.index(&(0..amt))) };
+ String::fmt(s, f)
}
}
}
macro_rules! floating { ($ty:ident) => {
+
impl Show for $ty {
+ fn fmt(&self, fmt: &mut Formatter) -> Result {
+ try!(String::fmt(self, fmt));
+ fmt.write_str(stringify!($ty))
+ }
+ }
+
+ impl String for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Float;
impl<T> Show for *const T {
fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
}
-
+impl<T> String for *const T {
+ fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
+}
impl<T> Show for *mut T {
fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
}
+impl<T> String for *mut T {
+ fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
+}
macro_rules! peel {
($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
if n > 0 {
try!(write!(f, ", "));
}
- try!(write!(f, "{}", *$name));
+ try!(write!(f, "{:?}", *$name));
n += 1;
)*
if n == 1 {
}
impl<T: Show> Show for [T] {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
+ try!(write!(f, "["));
+ }
+ let mut is_first = true;
+ for x in self.iter() {
+ if is_first {
+ is_first = false;
+ } else {
+ try!(write!(f, ", "));
+ }
+ try!(write!(f, "{:?}", *x))
+ }
+ if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
+ try!(write!(f, "]"));
+ }
+ Ok(())
+ }
+}
+
+#[cfg(stage0)]
+impl<T: Show> String for [T] {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
+ try!(write!(f, "["));
+ }
+ let mut is_first = true;
+ for x in self.iter() {
+ if is_first {
+ is_first = false;
+ } else {
+ try!(write!(f, ", "));
+ }
+ try!(write!(f, "{}", *x))
+ }
+ if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
+ try!(write!(f, "]"));
+ }
+ Ok(())
+ }
+}
+#[cfg(not(stage0))]
+impl<T: String> String for [T] {
fn fmt(&self, f: &mut Formatter) -> Result {
if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
try!(write!(f, "["));
}
}
+impl String for () {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ f.pad("()")
+ }
+}
+
impl<T: Copy + Show> Show for Cell<T> {
fn fmt(&self, f: &mut Formatter) -> Result {
- write!(f, "Cell {{ value: {} }}", self.get())
+ write!(f, "Cell {{ value: {:?} }}", self.get())
+ }
+}
+
+#[unstable]
+impl<T: Show> Show for RefCell<T> {
+ fn fmt(&self, f: &mut Formatter) -> Result {
+ match self.try_borrow() {
+ Some(val) => write!(f, "RefCell {{ value: {:?} }}", val),
+ None => write!(f, "RefCell {{ <borrowed> }}")
+ }
}
}
impl<'b, T: Show> Show for Ref<'b, T> {
fn fmt(&self, f: &mut Formatter) -> Result {
- (**self).fmt(f)
+ Show::fmt(&**self, f)
}
}
impl<'b, T: Show> Show for RefMut<'b, T> {
fn fmt(&self, f: &mut Formatter) -> Result {
- (*(self.deref())).fmt(f)
+ Show::fmt(&*(self.deref()), f)
}
}
-impl Show for Utf8Error {
+impl String for Utf8Error {
fn fmt(&self, f: &mut Formatter) -> Result {
match *self {
Utf8Error::InvalidByte(n) => {
use fmt;
use iter::IteratorExt;
+use ops::Index;
use num::{Int, cast};
use slice::SliceExt;
use str;
if x == zero { break }; // No more digits left to accumulate.
}
}
- let buf = unsafe { str::from_utf8_unchecked(buf[curr..]) };
+ let buf = unsafe { str::from_utf8_unchecked(buf.index(&(curr..))) };
f.pad_integral(is_positive, self.prefix(), buf)
}
}
}
macro_rules! radix_fmt {
- ($T:ty as $U:ty, $fmt:ident) => {
+ ($T:ty as $U:ty, $fmt:ident, $S:expr) => {
+ #[cfg(stage0)]
impl fmt::Show for RadixFmt<$T, Radix> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+ }
+
+ #[cfg(not(stage0))]
+ impl fmt::Show for RadixFmt<$T, Radix> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ try!(fmt::String::fmt(self, f));
+ f.write_str($S)
+ }
+ }
+ impl fmt::String for RadixFmt<$T, Radix> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self { RadixFmt(ref x, radix) => radix.$fmt(*x as $U, f) }
}
}
}
}
+
+macro_rules! show {
+ ($T:ident with $S:expr) => {
+ #[cfg(stage0)]
+ impl fmt::Show for $T {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+ }
+
+ #[cfg(not(stage0))]
+ impl fmt::Show for $T {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ try!(fmt::String::fmt(self, f));
+ f.write_str($S)
+ }
+ }
+ }
+}
macro_rules! integer {
($Int:ident, $Uint:ident) => {
- int_base! { Show for $Int as $Int -> Decimal }
+ integer! { $Int, $Uint, stringify!($Int), stringify!($Uint) }
+ };
+ ($Int:ident, $Uint:ident, $SI:expr, $SU:expr) => {
+ int_base! { String for $Int as $Int -> Decimal }
int_base! { Binary for $Int as $Uint -> Binary }
int_base! { Octal for $Int as $Uint -> Octal }
int_base! { LowerHex for $Int as $Uint -> LowerHex }
int_base! { UpperHex for $Int as $Uint -> UpperHex }
- radix_fmt! { $Int as $Int, fmt_int }
+ radix_fmt! { $Int as $Int, fmt_int, $SI }
+ show! { $Int with $SI }
- int_base! { Show for $Uint as $Uint -> Decimal }
+ int_base! { String for $Uint as $Uint -> Decimal }
int_base! { Binary for $Uint as $Uint -> Binary }
int_base! { Octal for $Uint as $Uint -> Octal }
int_base! { LowerHex for $Uint as $Uint -> LowerHex }
int_base! { UpperHex for $Uint as $Uint -> UpperHex }
- radix_fmt! { $Uint as $Uint, fmt_int }
+ radix_fmt! { $Uint as $Uint, fmt_int, $SU }
+ show! { $Uint with $SU }
}
}
-integer! { int, uint }
+integer! { int, uint, "i", "u" }
integer! { i8, u8 }
integer! { i16, u16 }
integer! { i32, u32 }
/// crate it is invoked in.
pub fn type_id<T: 'static>() -> TypeId;
-
/// Create a value initialized to zero.
///
/// `init` is unsafe because it returns a zeroed-out datum,
use ops::{Add, Deref, FnMut};
use option::Option;
use option::Option::{Some, None};
-use std::kinds::Sized;
+use std::marker::Sized;
use uint;
/// An interface for dealing with "external iterators". These types of iterators
/// ```
#[inline]
#[stable]
- fn last(mut self) -> Option< <Self as Iterator>::Item> {
+ fn last(mut self) -> Option<Self::Item> {
let mut last = None;
for x in self { last = Some(x); }
last
/// ```
#[inline]
#[stable]
- fn nth(&mut self, mut n: uint) -> Option< <Self as Iterator>::Item> {
+ fn nth(&mut self, mut n: uint) -> Option<Self::Item> {
for x in *self {
if n == 0 { return Some(x) }
n -= 1;
#[inline]
#[stable]
fn chain<U>(self, other: U) -> Chain<Self, U> where
- U: Iterator<Item=<Self as Iterator>::Item>,
+ U: Iterator<Item=Self::Item>,
{
Chain{a: self, b: other, flag: false}
}
/// ```
#[inline]
#[stable]
- fn map<B, F>(self, f: F) -> Map< <Self as Iterator>::Item, B, Self, F> where
- F: FnMut(<Self as Iterator>::Item) -> B,
+ fn map<B, F>(self, f: F) -> Map<Self::Item, B, Self, F> where
+ F: FnMut(Self::Item) -> B,
{
Map{iter: self, f: f}
}
/// ```
#[inline]
#[stable]
- fn filter<P>(self, predicate: P) -> Filter< <Self as Iterator>::Item, Self, P> where
- P: FnMut(&<Self as Iterator>::Item) -> bool,
+ fn filter<P>(self, predicate: P) -> Filter<Self::Item, Self, P> where
+ P: FnMut(&Self::Item) -> bool,
{
Filter{iter: self, predicate: predicate}
}
/// ```
#[inline]
#[stable]
- fn filter_map<B, F>(self, f: F) -> FilterMap< <Self as Iterator>::Item, B, Self, F> where
- F: FnMut(<Self as Iterator>::Item) -> Option<B>,
+ fn filter_map<B, F>(self, f: F) -> FilterMap<Self::Item, B, Self, F> where
+ F: FnMut(Self::Item) -> Option<B>,
{
FilterMap { iter: self, f: f }
}
/// ```
#[inline]
#[stable]
- fn peekable(self) -> Peekable< <Self as Iterator>::Item, Self> {
+ fn peekable(self) -> Peekable<Self::Item, Self> {
Peekable{iter: self, peeked: None}
}
/// ```
#[inline]
#[stable]
- fn skip_while<P>(self, predicate: P) -> SkipWhile< <Self as Iterator>::Item, Self, P> where
- P: FnMut(&<Self as Iterator>::Item) -> bool,
+ fn skip_while<P>(self, predicate: P) -> SkipWhile<Self::Item, Self, P> where
+ P: FnMut(&Self::Item) -> bool,
{
SkipWhile{iter: self, flag: false, predicate: predicate}
}
/// ```
#[inline]
#[stable]
- fn take_while<P>(self, predicate: P) -> TakeWhile< <Self as Iterator>::Item, Self, P> where
- P: FnMut(&<Self as Iterator>::Item) -> bool,
+ fn take_while<P>(self, predicate: P) -> TakeWhile<Self::Item, Self, P> where
+ P: FnMut(&Self::Item) -> bool,
{
TakeWhile{iter: self, flag: false, predicate: predicate}
}
self,
initial_state: St,
f: F,
- ) -> Scan< <Self as Iterator>::Item, B, Self, St, F> where
- F: FnMut(&mut St, <Self as Iterator>::Item) -> Option<B>,
+ ) -> Scan<Self::Item, B, Self, St, F> where
+ F: FnMut(&mut St, Self::Item) -> Option<B>,
{
Scan{iter: self, f: f, state: initial_state}
}
/// ```
#[inline]
#[stable]
- fn flat_map<B, U, F>(self, f: F) -> FlatMap< <Self as Iterator>::Item, B, Self, U, F> where
+ fn flat_map<B, U, F>(self, f: F) -> FlatMap<Self::Item, B, Self, U, F> where
U: Iterator<Item=B>,
- F: FnMut(<Self as Iterator>::Item) -> U,
+ F: FnMut(Self::Item) -> U,
{
FlatMap{iter: self, f: f, frontiter: None, backiter: None }
}
/// ```
#[inline]
#[stable]
- fn inspect<F>(self, f: F) -> Inspect< <Self as Iterator>::Item, Self, F> where
- F: FnMut(&<Self as Iterator>::Item),
+ fn inspect<F>(self, f: F) -> Inspect<Self::Item, Self, F> where
+ F: FnMut(&Self::Item),
{
Inspect{iter: self, f: f}
}
/// ```
#[inline]
#[stable]
- fn collect<B: FromIterator< <Self as Iterator>::Item>>(self) -> B {
+ fn collect<B: FromIterator<Self::Item>>(self) -> B {
FromIterator::from_iter(self)
}
/// ```
#[unstable = "recently added as part of collections reform"]
fn partition<B, F>(mut self, mut f: F) -> (B, B) where
- B: Default + Extend< <Self as Iterator>::Item>,
- F: FnMut(&<Self as Iterator>::Item) -> bool
+ B: Default + Extend<Self::Item>,
+ F: FnMut(&Self::Item) -> bool
{
let mut left: B = Default::default();
let mut right: B = Default::default();
#[inline]
#[stable]
fn fold<B, F>(mut self, init: B, mut f: F) -> B where
- F: FnMut(B, <Self as Iterator>::Item) -> B,
+ F: FnMut(B, Self::Item) -> B,
{
let mut accum = init;
for x in self {
/// ```
#[inline]
#[stable]
- fn all<F>(mut self, mut f: F) -> bool where F: FnMut(<Self as Iterator>::Item) -> bool {
+ fn all<F>(mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool {
for x in self { if !f(x) { return false; } }
true
}
/// ```
#[inline]
#[stable]
- fn any<F>(&mut self, mut f: F) -> bool where F: FnMut(<Self as Iterator>::Item) -> bool {
+ fn any<F>(&mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool {
for x in *self { if f(x) { return true; } }
false
}
/// Does not consume the iterator past the first found element.
#[inline]
#[stable]
- fn find<P>(&mut self, mut predicate: P) -> Option< <Self as Iterator>::Item> where
- P: FnMut(&<Self as Iterator>::Item) -> bool,
+ fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
+ P: FnMut(&Self::Item) -> bool,
{
for x in *self {
if predicate(&x) { return Some(x) }
#[inline]
#[stable]
fn position<P>(&mut self, mut predicate: P) -> Option<uint> where
- P: FnMut(<Self as Iterator>::Item) -> bool,
+ P: FnMut(Self::Item) -> bool,
{
let mut i = 0;
for x in *self {
#[inline]
#[stable]
fn rposition<P>(&mut self, mut predicate: P) -> Option<uint> where
- P: FnMut(<Self as Iterator>::Item) -> bool,
+ P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator
{
let len = self.len();
/// ```
#[inline]
#[stable]
- fn max(self) -> Option< <Self as Iterator>::Item> where
- <Self as Iterator>::Item: Ord
+ fn max(self) -> Option<Self::Item> where Self::Item: Ord
{
self.fold(None, |max, x| {
match max {
/// ```
#[inline]
#[stable]
- fn min(self) -> Option< <Self as Iterator>::Item> where
- <Self as Iterator>::Item: Ord
+ fn min(self) -> Option<Self::Item> where Self::Item: Ord
{
self.fold(None, |min, x| {
match min {
/// assert!(v.iter().min_max() == MinMax(&1, &1));
/// ```
#[unstable = "return type may change"]
- fn min_max(mut self) -> MinMaxResult< <Self as Iterator>::Item> where
- <Self as Iterator>::Item: Ord
+ fn min_max(mut self) -> MinMaxResult<Self::Item> where Self::Item: Ord
{
let (mut min, mut max) = match self.next() {
None => return NoElements,
/// ```
#[inline]
#[unstable = "may want to produce an Ordering directly; see #15311"]
- fn max_by<B: Ord, F>(self, mut f: F) -> Option< <Self as Iterator>::Item> where
- F: FnMut(&<Self as Iterator>::Item) -> B,
+ fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
+ F: FnMut(&Self::Item) -> B,
{
- self.fold(None, |max: Option<(<Self as Iterator>::Item, B)>, x| {
+ self.fold(None, |max: Option<(Self::Item, B)>, x| {
let x_val = f(&x);
match max {
None => Some((x, x_val)),
/// ```
#[inline]
#[unstable = "may want to produce an Ordering directly; see #15311"]
- fn min_by<B: Ord, F>(self, mut f: F) -> Option< <Self as Iterator>::Item> where
- F: FnMut(&<Self as Iterator>::Item) -> B,
+ fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
+ F: FnMut(&Self::Item) -> B,
{
- self.fold(None, |min: Option<(<Self as Iterator>::Item, B)>, x| {
+ self.fold(None, |min: Option<(Self::Item, B)>, x| {
let x_val = f(&x);
match min {
None => Some((x, x_val)),
#[stable]
pub trait DoubleEndedIterator: Iterator {
/// Yield an element from the end of the range, returning `None` if the range is empty.
- fn next_back(&mut self) -> Option< <Self as Iterator>::Item>;
+ fn next_back(&mut self) -> Option<Self::Item>;
}
/// An object implementing random access indexing by `uint`
fn indexable(&self) -> uint;
/// Return an element at an index, or `None` if the index is out of bounds
- fn idx(&mut self, index: uint) -> Option< <Self as Iterator>::Item>;
+ fn idx(&mut self, index: uint) -> Option<Self::Item>;
}
/// An iterator that knows its exact length
impl<I> ExactSizeIterator for Enumerate<I> where I: ExactSizeIterator {}
#[stable]
impl<A, I, F> ExactSizeIterator for Inspect<A, I, F> where
- I: ExactSizeIterator + Iterator<Item=A>,
+ I: ExactSizeIterator<Item=A>,
F: FnMut(&A),
{}
#[stable]
impl<I> ExactSizeIterator for Rev<I> where I: ExactSizeIterator + DoubleEndedIterator {}
#[stable]
impl<A, B, I, F> ExactSizeIterator for Map<A, B, I, F> where
- I: ExactSizeIterator + Iterator<Item=A>,
+ I: ExactSizeIterator<Item=A>,
F: FnMut(A) -> B,
{}
#[stable]
type Item = <I as Iterator>::Item;
#[inline]
- fn next(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next_back() }
+ fn next(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next_back() }
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {
#[inline]
- fn next_back(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next() }
+ fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }
}
#[experimental = "trait is experimental"]
#[inline]
fn indexable(&self) -> uint { self.iter.indexable() }
#[inline]
- fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
+ fn idx(&mut self, index: uint) -> Option<<I as Iterator>::Item> {
let amt = self.indexable();
self.iter.idx(amt - index - 1)
}
type Item = <I as Iterator>::Item;
#[inline]
- fn next(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next() }
+ fn next(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }
#[inline]
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
#[stable]
impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterator {
#[inline]
- fn next_back(&mut self) -> Option< <I as Iterator>::Item> { self.iter.next_back() }
+ fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next_back() }
}
/// A trait for iterators over elements which can be added together
impl<T, D, I> DoubleEndedIterator for Cloned<I> where
T: Clone,
D: Deref<Target=T>,
- I: DoubleEndedIterator + Iterator<Item=D>,
+ I: DoubleEndedIterator<Item=D>,
{
fn next_back(&mut self) -> Option<T> {
self.it.next_back().cloned()
impl<T, D, I> ExactSizeIterator for Cloned<I> where
T: Clone,
D: Deref<Target=T>,
- I: ExactSizeIterator + Iterator<Item=D>,
+ I: ExactSizeIterator<Item=D>,
{}
/// An iterator that repeats endlessly
type Item = <I as Iterator>::Item;
#[inline]
- fn next(&mut self) -> Option< <I as Iterator>::Item> {
+ fn next(&mut self) -> Option<<I as Iterator>::Item> {
match self.iter.next() {
None => { self.iter = self.orig.clone(); self.iter.next() }
y => y
}
#[inline]
- fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
+ fn idx(&mut self, index: uint) -> Option<<I as Iterator>::Item> {
let liter = self.iter.indexable();
let lorig = self.orig.indexable();
if lorig == 0 {
#[stable]
impl<T, A, B> DoubleEndedIterator for Chain<A, B> where
- A: DoubleEndedIterator + Iterator<Item=T>,
- B: DoubleEndedIterator + Iterator<Item=T>,
+ A: DoubleEndedIterator<Item=T>,
+ B: DoubleEndedIterator<Item=T>,
{
#[inline]
fn next_back(&mut self) -> Option<T> {
#[experimental = "trait is experimental"]
impl<T, A, B> RandomAccessIterator for Chain<A, B> where
- A: RandomAccessIterator + Iterator<Item=T>,
- B: RandomAccessIterator + Iterator<Item=T>,
+ A: RandomAccessIterator<Item=T>,
+ B: RandomAccessIterator<Item=T>,
{
#[inline]
fn indexable(&self) -> uint {
#[stable]
impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where
- A: ExactSizeIterator + Iterator<Item=T> + DoubleEndedIterator,
- B: ExactSizeIterator + Iterator<Item=U> + DoubleEndedIterator,
+ A: DoubleEndedIterator + ExactSizeIterator<Item=T>,
+ B: DoubleEndedIterator + ExactSizeIterator<Item=U>,
{
#[inline]
fn next_back(&mut self) -> Option<(T, U)> {
#[experimental = "trait is experimental"]
impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where
- A: RandomAccessIterator + Iterator<Item=T>,
- B: RandomAccessIterator + Iterator<Item=U>,
+ A: RandomAccessIterator<Item=T>,
+ B: RandomAccessIterator<Item=U>,
{
#[inline]
fn indexable(&self) -> uint {
#[stable]
impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where
- I: DoubleEndedIterator + Iterator<Item=A>,
+ I: DoubleEndedIterator<Item=A>,
F: FnMut(A) -> B,
{
#[inline]
#[experimental = "trait is experimental"]
impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where
- I: RandomAccessIterator + Iterator<Item=A>,
+ I: RandomAccessIterator<Item=A>,
F: FnMut(A) -> B,
{
#[inline]
#[stable]
impl<A, I, P> DoubleEndedIterator for Filter<A, I, P> where
- I: DoubleEndedIterator + Iterator<Item=A>,
+ I: DoubleEndedIterator<Item=A>,
P: FnMut(&A) -> bool,
{
#[inline]
#[stable]
impl<A, B, I, F> DoubleEndedIterator for FilterMap<A, B, I, F> where
- I: DoubleEndedIterator + Iterator<Item=A>,
+ I: DoubleEndedIterator<Item=A>,
F: FnMut(A) -> Option<B>,
{
#[inline]
type Item = <I as Iterator>::Item;
#[inline]
- fn next(&mut self) -> Option< <I as Iterator>::Item> {
+ fn next(&mut self) -> Option<<I as Iterator>::Item> {
let mut next = self.iter.next();
if self.n == 0 {
next
}
#[inline]
- fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
+ fn idx(&mut self, index: uint) -> Option<<I as Iterator>::Item> {
if index >= self.indexable() {
None
} else {
type Item = <I as Iterator>::Item;
#[inline]
- fn next(&mut self) -> Option< <I as Iterator>::Item> {
+ fn next(&mut self) -> Option<<I as Iterator>::Item> {
if self.n != 0 {
self.n -= 1;
self.iter.next()
}
#[inline]
- fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
+ fn idx(&mut self, index: uint) -> Option<<I as Iterator>::Item> {
if index >= self.n {
None
} else {
#[stable]
impl<A, B, I, U, F> DoubleEndedIterator for FlatMap<A, B, I, U, F> where
- I: DoubleEndedIterator + Iterator<Item=A>,
- U: DoubleEndedIterator + Iterator<Item=B>,
+ I: DoubleEndedIterator<Item=A>,
+ U: DoubleEndedIterator<Item=B>,
F: FnMut(A) -> U,
{
#[inline]
type Item = <I as Iterator>::Item;
#[inline]
- fn next(&mut self) -> Option< <I as Iterator>::Item> {
+ fn next(&mut self) -> Option<<I as Iterator>::Item> {
if self.done {
None
} else {
#[stable]
impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
#[inline]
- fn next_back(&mut self) -> Option< <I as Iterator>::Item> {
+ fn next_back(&mut self) -> Option<<I as Iterator>::Item> {
if self.done {
None
} else {
}
#[inline]
- fn idx(&mut self, index: uint) -> Option< <I as Iterator>::Item> {
+ fn idx(&mut self, index: uint) -> Option<<I as Iterator>::Item> {
self.iter.idx(index)
}
}
#[stable]
impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where
- I: DoubleEndedIterator + Iterator<Item=A>,
+ I: DoubleEndedIterator<Item=A>,
F: FnMut(&A),
{
#[inline]
#[experimental = "trait is experimental"]
impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
- I: RandomAccessIterator + Iterator<Item=A>,
+ I: RandomAccessIterator<Item=A>,
F: FnMut(&A),
{
#[inline]
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Primitive traits representing basic 'kinds' of types
-//!
-//! Rust types can be classified in various useful ways according to
-//! intrinsic properties of the type. These classifications, often called
-//! 'kinds', are represented as traits.
-//!
-//! They cannot be implemented by user code, but are instead implemented
-//! by the compiler automatically for the types to which they apply.
-
-/// Types able to be transferred across task boundaries.
-#[lang="send"]
-pub unsafe trait Send : 'static {
- // empty.
-}
-
-/// Types with a constant size known at compile-time.
-#[lang="sized"]
-pub trait Sized {
- // Empty.
-}
-
-/// Types that can be copied by simply copying bits (i.e. `memcpy`).
-#[lang="copy"]
-pub trait Copy {
- // Empty.
-}
-
-/// Types that can be safely shared between tasks when aliased.
-///
-/// The precise definition is: a type `T` is `Sync` if `&T` is
-/// thread-safe. In other words, there is no possibility of data races
-/// when passing `&T` references between tasks.
-///
-/// As one would expect, primitive types like `u8` and `f64` are all
-/// `Sync`, and so are simple aggregate types containing them (like
-/// tuples, structs and enums). More instances of basic `Sync` types
-/// include "immutable" types like `&T` and those with simple
-/// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
-/// collection types. (Generic parameters need to be `Sync` for their
-/// container to be `Sync`.)
-///
-/// A somewhat surprising consequence of the definition is `&mut T` is
-/// `Sync` (if `T` is `Sync`) even though it seems that it might
-/// provide unsynchronised mutation. The trick is a mutable reference
-/// stored in an aliasable reference (that is, `& &mut T`) becomes
-/// read-only, as if it were a `& &T`, hence there is no risk of a data
-/// race.
-///
-/// Types that are not `Sync` are those that have "interior
-/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
-/// in `std::cell`. These types allow for mutation of their contents
-/// even when in an immutable, aliasable slot, e.g. the contents of
-/// `&Cell<T>` can be `.set`, and do not ensure data races are
-/// impossible, hence they cannot be `Sync`. A higher level example
-/// of a non-`Sync` type is the reference counted pointer
-/// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
-/// reference, which modifies the reference counts in a non-atomic
-/// way.
-///
-/// For cases when one does need thread-safe interior mutability,
-/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
-/// the `sync` crate do ensure that any mutation cannot cause data
-/// races. Hence these types are `Sync`.
-///
-/// Users writing their own types with interior mutability (or anything
-/// else that is not thread-safe) should use the `NoSync` marker type
-/// (from `std::kinds::marker`) to ensure that the compiler doesn't
-/// consider the user-defined type to be `Sync`. Any types with
-/// interior mutability must also use the `std::cell::UnsafeCell` wrapper
-/// around the value(s) which can be mutated when behind a `&`
-/// reference; not doing this is undefined behaviour (for example,
-/// `transmute`-ing from `&T` to `&mut T` is illegal).
-#[lang="sync"]
-pub unsafe trait Sync {
- // Empty
-}
-
-/// Marker types are special types that are used with unsafe code to
-/// inform the compiler of special constraints. Marker types should
-/// only be needed when you are creating an abstraction that is
-/// implemented using unsafe code. In that case, you may want to embed
-/// some of the marker types below into your type.
-pub mod marker {
- use super::{Copy,Sized};
- use clone::Clone;
-
- /// A marker type whose type parameter `T` is considered to be
- /// covariant with respect to the type itself. This is (typically)
- /// used to indicate that an instance of the type `T` is being stored
- /// into memory and read from, even though that may not be apparent.
- ///
- /// For more information about variance, refer to this Wikipedia
- /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
- ///
- /// *Note:* It is very unusual to have to add a covariant constraint.
- /// If you are not sure, you probably want to use `InvariantType`.
- ///
- /// # Example
- ///
- /// Given a struct `S` that includes a type parameter `T`
- /// but does not actually *reference* that type parameter:
- ///
- /// ```ignore
- /// use std::mem;
- ///
- /// struct S<T> { x: *() }
- /// fn get<T>(s: &S<T>) -> T {
- /// unsafe {
- /// let x: *T = mem::transmute(s.x);
- /// *x
- /// }
- /// }
- /// ```
- ///
- /// The type system would currently infer that the value of
- /// the type parameter `T` is irrelevant, and hence a `S<int>` is
- /// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
- /// any `U`). But this is incorrect because `get()` converts the
- /// `*()` into a `*T` and reads from it. Therefore, we should include the
- /// a marker field `CovariantType<T>` to inform the type checker that
- /// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
- /// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
- /// for some lifetime `'a`, but not the other way around).
- #[lang="covariant_type"]
- #[derive(PartialEq, Eq, PartialOrd, Ord)]
- pub struct CovariantType<T: ?Sized>;
-
- impl<T: ?Sized> Copy for CovariantType<T> {}
- impl<T: ?Sized> Clone for CovariantType<T> {
- fn clone(&self) -> CovariantType<T> { *self }
- }
-
- /// A marker type whose type parameter `T` is considered to be
- /// contravariant with respect to the type itself. This is (typically)
- /// used to indicate that an instance of the type `T` will be consumed
- /// (but not read from), even though that may not be apparent.
- ///
- /// For more information about variance, refer to this Wikipedia
- /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
- ///
- /// *Note:* It is very unusual to have to add a contravariant constraint.
- /// If you are not sure, you probably want to use `InvariantType`.
- ///
- /// # Example
- ///
- /// Given a struct `S` that includes a type parameter `T`
- /// but does not actually *reference* that type parameter:
- ///
- /// ```
- /// use std::mem;
- ///
- /// struct S<T> { x: *const () }
- /// fn get<T>(s: &S<T>, v: T) {
- /// unsafe {
- /// let x: fn(T) = mem::transmute(s.x);
- /// x(v)
- /// }
- /// }
- /// ```
- ///
- /// The type system would currently infer that the value of
- /// the type parameter `T` is irrelevant, and hence a `S<int>` is
- /// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
- /// any `U`). But this is incorrect because `get()` converts the
- /// `*()` into a `fn(T)` and then passes a value of type `T` to it.
- ///
- /// Supplying a `ContravariantType` marker would correct the
- /// problem, because it would mark `S` so that `S<T>` is only a
- /// subtype of `S<U>` if `U` is a subtype of `T`; given that the
- /// function requires arguments of type `T`, it must also accept
- /// arguments of type `U`, hence such a conversion is safe.
- #[lang="contravariant_type"]
- #[derive(PartialEq, Eq, PartialOrd, Ord)]
- pub struct ContravariantType<T: ?Sized>;
-
- impl<T: ?Sized> Copy for ContravariantType<T> {}
- impl<T: ?Sized> Clone for ContravariantType<T> {
- fn clone(&self) -> ContravariantType<T> { *self }
- }
-
- /// A marker type whose type parameter `T` is considered to be
- /// invariant with respect to the type itself. This is (typically)
- /// used to indicate that instances of the type `T` may be read or
- /// written, even though that may not be apparent.
- ///
- /// For more information about variance, refer to this Wikipedia
- /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
- ///
- /// # Example
- ///
- /// The Cell type is an example which uses unsafe code to achieve
- /// "interior" mutability:
- ///
- /// ```
- /// pub struct Cell<T> { value: T }
- /// # fn main() {}
- /// ```
- ///
- /// The type system would infer that `value` is only read here and
- /// never written, but in fact `Cell` uses unsafe code to achieve
- /// interior mutability.
- #[lang="invariant_type"]
- #[derive(PartialEq, Eq, PartialOrd, Ord)]
- pub struct InvariantType<T: ?Sized>;
-
- impl<T: ?Sized> Copy for InvariantType<T> {}
- impl<T: ?Sized> Clone for InvariantType<T> {
- fn clone(&self) -> InvariantType<T> { *self }
- }
-
- /// As `CovariantType`, but for lifetime parameters. Using
- /// `CovariantLifetime<'a>` indicates that it is ok to substitute
- /// a *longer* lifetime for `'a` than the one you originally
- /// started with (e.g., you could convert any lifetime `'foo` to
- /// `'static`). You almost certainly want `ContravariantLifetime`
- /// instead, or possibly `InvariantLifetime`. The only case where
- /// it would be appropriate is that you have a (type-casted, and
- /// hence hidden from the type system) function pointer with a
- /// signature like `fn(&'a T)` (and no other uses of `'a`). In
- /// this case, it is ok to substitute a larger lifetime for `'a`
- /// (e.g., `fn(&'static T)`), because the function is only
- /// becoming more selective in terms of what it accepts as
- /// argument.
- ///
- /// For more information about variance, refer to this Wikipedia
- /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
- #[lang="covariant_lifetime"]
- #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
- pub struct CovariantLifetime<'a>;
-
- /// As `ContravariantType`, but for lifetime parameters. Using
- /// `ContravariantLifetime<'a>` indicates that it is ok to
- /// substitute a *shorter* lifetime for `'a` than the one you
- /// originally started with (e.g., you could convert `'static` to
- /// any lifetime `'foo`). This is appropriate for cases where you
- /// have an unsafe pointer that is actually a pointer into some
- /// memory with lifetime `'a`, and thus you want to limit the
- /// lifetime of your data structure to `'a`. An example of where
- /// this is used is the iterator for vectors.
- ///
- /// For more information about variance, refer to this Wikipedia
- /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
- #[lang="contravariant_lifetime"]
- #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
- pub struct ContravariantLifetime<'a>;
-
- /// As `InvariantType`, but for lifetime parameters. Using
- /// `InvariantLifetime<'a>` indicates that it is not ok to
- /// substitute any other lifetime for `'a` besides its original
- /// value. This is appropriate for cases where you have an unsafe
- /// pointer that is actually a pointer into memory with lifetime `'a`,
- /// and this pointer is itself stored in an inherently mutable
- /// location (such as a `Cell`).
- #[lang="invariant_lifetime"]
- #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
- pub struct InvariantLifetime<'a>;
-
- /// A type which is considered "not sendable", meaning that it cannot
- /// be safely sent between tasks, even if it is owned. This is
- /// typically embedded in other types, such as `Gc`, to ensure that
- /// their instances remain thread-local.
- #[lang="no_send_bound"]
- #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
- pub struct NoSend;
-
- /// A type which is considered "not POD", meaning that it is not
- /// implicitly copyable. This is typically embedded in other types to
- /// ensure that they are never copied, even if they lack a destructor.
- #[lang="no_copy_bound"]
- #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
- #[allow(missing_copy_implementations)]
- pub struct NoCopy;
-
- /// A type which is considered "not sync", meaning that
- /// its contents are not threadsafe, hence they cannot be
- /// shared between tasks.
- #[lang="no_sync_bound"]
- #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
- pub struct NoSync;
-
- /// A type which is considered managed by the GC. This is typically
- /// embedded in other types.
- #[lang="managed_bound"]
- #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
- #[allow(missing_copy_implementations)]
- pub struct Managed;
-}
-
html_playground_url = "http://play.rust-lang.org/")]
#![no_std]
-#![allow(unknown_features, raw_pointer_deriving)]
-#![feature(globs, intrinsics, lang_items, macro_rules, phase)]
+#![allow(unknown_features, raw_pointer_derive)]
+#![feature(intrinsics, lang_items)]
#![feature(simd, unsafe_destructor, slicing_syntax)]
-#![feature(default_type_params, unboxed_closures, associated_types)]
+#![feature(unboxed_closures)]
#![deny(missing_docs)]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod macros;
#[path = "num/float_macros.rs"]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod float_macros;
#[path = "num/int_macros.rs"]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod int_macros;
#[path = "num/uint_macros.rs"]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod uint_macros;
#[path = "num/int.rs"] pub mod int;
/* Core language traits */
-pub mod kinds;
+pub mod marker;
pub mod ops;
pub mod cmp;
pub mod clone;
mod std {
pub use clone;
pub use cmp;
- pub use kinds;
+ #[cfg(stage0)]
+ pub use marker as kinds;
+ pub use marker;
pub use option;
pub use fmt;
pub use hash;
if !((*left_val == *right_val) &&
(*right_val == *left_val)) {
panic!("assertion failed: `(left == right) && (right == left)` \
- (left: `{}`, right: `{}`)", *left_val, *right_val)
+ (left: `{:?}`, right: `{:?}`)", *left_val, *right_val)
}
}
}
($($arg:tt)*) => (if cfg!(not(ndebug)) { assert_eq!($($arg)*); })
}
-#[cfg(stage0)]
-#[macro_export]
-macro_rules! try {
- ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
-}
-
/// Short circuiting evaluation on Err
///
/// `libstd` contains a more general `try!` macro that uses `FromError`.
-#[cfg(not(stage0))]
#[macro_export]
macro_rules! try {
($e:expr) => ({
#[macro_export]
#[stable]
macro_rules! writeln {
- ($dst:expr, $fmt:expr $($arg:tt)*) => (
- write!($dst, concat!($fmt, "\n") $($arg)*)
- )
+ ($dst:expr, $fmt:expr) => (
+ write!($dst, concat!($fmt, "\n"))
+ );
+ ($dst:expr, $fmt:expr, $($arg:tt)*) => (
+ write!($dst, concat!($fmt, "\n"), $($arg)*)
+ );
}
/// A utility macro for indicating unreachable code.
--- /dev/null
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Primitive traits and marker types representing basic 'kinds' of types.
+//!
+//! Rust types can be classified in various useful ways according to
+//! intrinsic properties of the type. These classifications, often called
+//! 'kinds', are represented as traits.
+//!
+//! They cannot be implemented by user code, but are instead implemented
+//! by the compiler automatically for the types to which they apply.
+//!
+//! Marker types are special types that are used with unsafe code to
+//! inform the compiler of special constraints. Marker types should
+//! only be needed when you are creating an abstraction that is
+//! implemented using unsafe code. In that case, you may want to embed
+//! some of the marker types below into your type.
+
+#![stable]
+
+use clone::Clone;
+
+/// Types able to be transferred across task boundaries.
+#[unstable = "will be overhauled with new lifetime rules; see RFC 458"]
+#[lang="send"]
+pub unsafe trait Send: 'static {
+ // empty.
+}
+
+/// Types with a constant size known at compile-time.
+#[stable]
+#[lang="sized"]
+pub trait Sized {
+ // Empty.
+}
+
+/// Types that can be copied by simply copying bits (i.e. `memcpy`).
+#[stable]
+#[lang="copy"]
+pub trait Copy {
+ // Empty.
+}
+
+/// Types that can be safely shared between tasks when aliased.
+///
+/// The precise definition is: a type `T` is `Sync` if `&T` is
+/// thread-safe. In other words, there is no possibility of data races
+/// when passing `&T` references between tasks.
+///
+/// As one would expect, primitive types like `u8` and `f64` are all
+/// `Sync`, and so are simple aggregate types containing them (like
+/// tuples, structs and enums). More instances of basic `Sync` types
+/// include "immutable" types like `&T` and those with simple
+/// inherited mutability, such as `Box<T>`, `Vec<T>` and most other
+/// collection types. (Generic parameters need to be `Sync` for their
+/// container to be `Sync`.)
+///
+/// A somewhat surprising consequence of the definition is `&mut T` is
+/// `Sync` (if `T` is `Sync`) even though it seems that it might
+/// provide unsynchronised mutation. The trick is a mutable reference
+/// stored in an aliasable reference (that is, `& &mut T`) becomes
+/// read-only, as if it were a `& &T`, hence there is no risk of a data
+/// race.
+///
+/// Types that are not `Sync` are those that have "interior
+/// mutability" in a non-thread-safe way, such as `Cell` and `RefCell`
+/// in `std::cell`. These types allow for mutation of their contents
+/// even when in an immutable, aliasable slot, e.g. the contents of
+/// `&Cell<T>` can be `.set`, and do not ensure data races are
+/// impossible, hence they cannot be `Sync`. A higher level example
+/// of a non-`Sync` type is the reference counted pointer
+/// `std::rc::Rc`, because any reference `&Rc<T>` can clone a new
+/// reference, which modifies the reference counts in a non-atomic
+/// way.
+///
+/// For cases when one does need thread-safe interior mutability,
+/// types like the atomics in `std::sync` and `Mutex` & `RWLock` in
+/// the `sync` crate do ensure that any mutation cannot cause data
+/// races. Hence these types are `Sync`.
+///
+/// Users writing their own types with interior mutability (or anything
+/// else that is not thread-safe) should use the `NoSync` marker type
+/// (from `std::marker`) to ensure that the compiler doesn't
+/// consider the user-defined type to be `Sync`. Any types with
+/// interior mutability must also use the `std::cell::UnsafeCell` wrapper
+/// around the value(s) which can be mutated when behind a `&`
+/// reference; not doing this is undefined behaviour (for example,
+/// `transmute`-ing from `&T` to `&mut T` is illegal).
+#[unstable = "will be overhauled with new lifetime rules; see RFC 458"]
+#[lang="sync"]
+pub unsafe trait Sync {
+ // Empty
+}
+
+
+/// A marker type whose type parameter `T` is considered to be
+/// covariant with respect to the type itself. This is (typically)
+/// used to indicate that an instance of the type `T` is being stored
+/// into memory and read from, even though that may not be apparent.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+///
+/// *Note:* It is very unusual to have to add a covariant constraint.
+/// If you are not sure, you probably want to use `InvariantType`.
+///
+/// # Example
+///
+/// Given a struct `S` that includes a type parameter `T`
+/// but does not actually *reference* that type parameter:
+///
+/// ```ignore
+/// use std::mem;
+///
+/// struct S<T> { x: *() }
+/// fn get<T>(s: &S<T>) -> T {
+/// unsafe {
+/// let x: *T = mem::transmute(s.x);
+/// *x
+/// }
+/// }
+/// ```
+///
+/// The type system would currently infer that the value of
+/// the type parameter `T` is irrelevant, and hence a `S<int>` is
+/// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
+/// any `U`). But this is incorrect because `get()` converts the
+/// `*()` into a `*T` and reads from it. Therefore, we should include the
+/// a marker field `CovariantType<T>` to inform the type checker that
+/// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
+/// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
+/// for some lifetime `'a`, but not the other way around).
+#[unstable = "likely to change with new variance strategy"]
+#[lang="covariant_type"]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct CovariantType<T: ?Sized>;
+
+impl<T: ?Sized> Copy for CovariantType<T> {}
+impl<T: ?Sized> Clone for CovariantType<T> {
+ fn clone(&self) -> CovariantType<T> { *self }
+}
+
+/// A marker type whose type parameter `T` is considered to be
+/// contravariant with respect to the type itself. This is (typically)
+/// used to indicate that an instance of the type `T` will be consumed
+/// (but not read from), even though that may not be apparent.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+///
+/// *Note:* It is very unusual to have to add a contravariant constraint.
+/// If you are not sure, you probably want to use `InvariantType`.
+///
+/// # Example
+///
+/// Given a struct `S` that includes a type parameter `T`
+/// but does not actually *reference* that type parameter:
+///
+/// ```
+/// use std::mem;
+///
+/// struct S<T> { x: *const () }
+/// fn get<T>(s: &S<T>, v: T) {
+/// unsafe {
+/// let x: fn(T) = mem::transmute(s.x);
+/// x(v)
+/// }
+/// }
+/// ```
+///
+/// The type system would currently infer that the value of
+/// the type parameter `T` is irrelevant, and hence a `S<int>` is
+/// a subtype of `S<Box<int>>` (or, for that matter, `S<U>` for
+/// any `U`). But this is incorrect because `get()` converts the
+/// `*()` into a `fn(T)` and then passes a value of type `T` to it.
+///
+/// Supplying a `ContravariantType` marker would correct the
+/// problem, because it would mark `S` so that `S<T>` is only a
+/// subtype of `S<U>` if `U` is a subtype of `T`; given that the
+/// function requires arguments of type `T`, it must also accept
+/// arguments of type `U`, hence such a conversion is safe.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="contravariant_type"]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct ContravariantType<T: ?Sized>;
+
+impl<T: ?Sized> Copy for ContravariantType<T> {}
+impl<T: ?Sized> Clone for ContravariantType<T> {
+ fn clone(&self) -> ContravariantType<T> { *self }
+}
+
+/// A marker type whose type parameter `T` is considered to be
+/// invariant with respect to the type itself. This is (typically)
+/// used to indicate that instances of the type `T` may be read or
+/// written, even though that may not be apparent.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+///
+/// # Example
+///
+/// The Cell type is an example which uses unsafe code to achieve
+/// "interior" mutability:
+///
+/// ```
+/// pub struct Cell<T> { value: T }
+/// # fn main() {}
+/// ```
+///
+/// The type system would infer that `value` is only read here and
+/// never written, but in fact `Cell` uses unsafe code to achieve
+/// interior mutability.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="invariant_type"]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct InvariantType<T: ?Sized>;
+
+#[unstable = "likely to change with new variance strategy"]
+impl<T: ?Sized> Copy for InvariantType<T> {}
+#[unstable = "likely to change with new variance strategy"]
+impl<T: ?Sized> Clone for InvariantType<T> {
+ fn clone(&self) -> InvariantType<T> { *self }
+}
+
+/// As `CovariantType`, but for lifetime parameters. Using
+/// `CovariantLifetime<'a>` indicates that it is ok to substitute
+/// a *longer* lifetime for `'a` than the one you originally
+/// started with (e.g., you could convert any lifetime `'foo` to
+/// `'static`). You almost certainly want `ContravariantLifetime`
+/// instead, or possibly `InvariantLifetime`. The only case where
+/// it would be appropriate is that you have a (type-casted, and
+/// hence hidden from the type system) function pointer with a
+/// signature like `fn(&'a T)` (and no other uses of `'a`). In
+/// this case, it is ok to substitute a larger lifetime for `'a`
+/// (e.g., `fn(&'static T)`), because the function is only
+/// becoming more selective in terms of what it accepts as
+/// argument.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="covariant_lifetime"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct CovariantLifetime<'a>;
+
+/// As `ContravariantType`, but for lifetime parameters. Using
+/// `ContravariantLifetime<'a>` indicates that it is ok to
+/// substitute a *shorter* lifetime for `'a` than the one you
+/// originally started with (e.g., you could convert `'static` to
+/// any lifetime `'foo`). This is appropriate for cases where you
+/// have an unsafe pointer that is actually a pointer into some
+/// memory with lifetime `'a`, and thus you want to limit the
+/// lifetime of your data structure to `'a`. An example of where
+/// this is used is the iterator for vectors.
+///
+/// For more information about variance, refer to this Wikipedia
+/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="contravariant_lifetime"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ContravariantLifetime<'a>;
+
+/// As `InvariantType`, but for lifetime parameters. Using
+/// `InvariantLifetime<'a>` indicates that it is not ok to
+/// substitute any other lifetime for `'a` besides its original
+/// value. This is appropriate for cases where you have an unsafe
+/// pointer that is actually a pointer into memory with lifetime `'a`,
+/// and this pointer is itself stored in an inherently mutable
+/// location (such as a `Cell`).
+#[unstable = "likely to change with new variance strategy"]
+#[lang="invariant_lifetime"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct InvariantLifetime<'a>;
+
+/// A type which is considered "not sendable", meaning that it cannot
+/// be safely sent between tasks, even if it is owned. This is
+/// typically embedded in other types, such as `Gc`, to ensure that
+/// their instances remain thread-local.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="no_send_bound"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct NoSend;
+
+/// A type which is considered "not POD", meaning that it is not
+/// implicitly copyable. This is typically embedded in other types to
+/// ensure that they are never copied, even if they lack a destructor.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="no_copy_bound"]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[allow(missing_copy_implementations)]
+pub struct NoCopy;
+
+/// A type which is considered "not sync", meaning that
+/// its contents are not threadsafe, hence they cannot be
+/// shared between tasks.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="no_sync_bound"]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct NoSync;
+
+/// A type which is considered managed by the GC. This is typically
+/// embedded in other types.
+#[unstable = "likely to change with new variance strategy"]
+#[lang="managed_bound"]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[allow(missing_copy_implementations)]
+pub struct Managed;
#![stable]
-use kinds::Sized;
+use marker::Sized;
use intrinsics;
use ptr;
use cmp::{PartialOrd, Ord};
use intrinsics;
use iter::IteratorExt;
-use kinds::Copy;
+use marker::Copy;
use mem::size_of;
use ops::{Add, Sub, Mul, Div, Rem, Neg};
-use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
+use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr, Index};
use option::Option;
use option::Option::{Some, None};
use str::{FromStr, StrExt};
/// A generic trait for converting a number to a value.
#[experimental = "trait is likely to be removed"]
-pub trait FromPrimitive : ::kinds::Sized {
+pub trait FromPrimitive : ::marker::Sized {
/// Convert an `int` to return an optional value of this type. If the
/// value cannot be represented by this value, the `None` is returned.
#[inline]
};
// Parse the exponent as decimal integer
- let src = src[offset..];
+ let src = src.index(&(offset..));
let (is_positive, exp) = match src.slice_shift_char() {
Some(('-', src)) => (false, src.parse::<uint>()),
Some(('+', src)) => (true, src.parse::<uint>()),
//! }
//! }
//! fn main() {
-//! println!("{}", Point {x: 1, y: 0} + Point {x: 2, y: 3});
-//! println!("{}", Point {x: 1, y: 0} - Point {x: 2, y: 3});
+//! println!("{:?}", Point {x: 1, y: 0} + Point {x: 2, y: 3});
+//! println!("{:?}", Point {x: 1, y: 0} - Point {x: 2, y: 3});
//! }
//! ```
//!
use clone::Clone;
use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
-use kinds::Sized;
+use marker::Sized;
use option::Option::{self, Some, None};
/// The `Drop` trait is used to run some code when a value goes out of scope. This
fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Self::Output;
}
-/// The `Slice` trait is used to specify the functionality of slicing operations
-/// like `arr[from..to]` when used in an immutable context.
-///
-/// # Example
-///
-/// A trivial implementation of `Slice`. When `Foo[..Foo]` happens, it ends up
-/// calling `slice_to`, and therefore, `main` prints `Slicing!`.
-///
-/// ```ignore
-/// use std::ops::Slice;
-///
-/// #[derive(Copy)]
-/// struct Foo;
-///
-/// impl Slice<Foo, Foo> for Foo {
-/// fn as_slice_<'a>(&'a self) -> &'a Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// fn slice_from_or_fail<'a>(&'a self, _from: &Foo) -> &'a Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// fn slice_to_or_fail<'a>(&'a self, _to: &Foo) -> &'a Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// fn slice_or_fail<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// }
-///
-/// fn main() {
-/// Foo[..Foo];
-/// }
-/// ```
-#[lang="slice"]
-pub trait Slice<Idx: ?Sized, Result: ?Sized> {
- /// The method for the slicing operation foo[]
- fn as_slice_<'a>(&'a self) -> &'a Result;
- /// The method for the slicing operation foo[from..]
- fn slice_from_or_fail<'a>(&'a self, from: &Idx) -> &'a Result;
- /// The method for the slicing operation foo[..to]
- fn slice_to_or_fail<'a>(&'a self, to: &Idx) -> &'a Result;
- /// The method for the slicing operation foo[from..to]
- fn slice_or_fail<'a>(&'a self, from: &Idx, to: &Idx) -> &'a Result;
-}
-
-/// The `SliceMut` trait is used to specify the functionality of slicing
-/// operations like `arr[from..to]`, when used in a mutable context.
-///
-/// # Example
-///
-/// A trivial implementation of `SliceMut`. When `Foo[Foo..]` happens, it ends up
-/// calling `slice_from_mut`, and therefore, `main` prints `Slicing!`.
-///
-/// ```ignore
-/// use std::ops::SliceMut;
-///
-/// #[derive(Copy)]
-/// struct Foo;
-///
-/// impl SliceMut<Foo, Foo> for Foo {
-/// fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// fn slice_from_or_fail_mut<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// fn slice_to_or_fail_mut<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// fn slice_or_fail_mut<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo {
-/// println!("Slicing!");
-/// self
-/// }
-/// }
-///
-/// pub fn main() {
-/// Foo[mut Foo..];
-/// }
-/// ```
-#[lang="slice_mut"]
-pub trait SliceMut<Idx: ?Sized, Result: ?Sized> {
- /// The method for the slicing operation foo[]
- fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Result;
- /// The method for the slicing operation foo[from..]
- fn slice_from_or_fail_mut<'a>(&'a mut self, from: &Idx) -> &'a mut Result;
- /// The method for the slicing operation foo[..to]
- fn slice_to_or_fail_mut<'a>(&'a mut self, to: &Idx) -> &'a mut Result;
- /// The method for the slicing operation foo[from..to]
- fn slice_or_fail_mut<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result;
-}
-
-
/// An unbounded range.
#[derive(Copy)]
#[lang="full_range"]
pub end: Idx,
}
-// FIXME(#19391) needs a snapshot
-//impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
#[unstable = "API still in development"]
impl<Idx: Clone + Step> Iterator for Range<Idx> {
type Item = Idx;
pub trait DerefMut: Deref {
/// The method called to mutably dereference a value
#[stable]
- fn deref_mut<'a>(&'a mut self) -> &'a mut <Self as Deref>::Target;
+ fn deref_mut<'a>(&'a mut self) -> &'a mut Self::Target;
}
#[stable]
/// // First, cast `Option<String>` to `Option<&String>` with `as_ref`,
/// // then consume *that* with `map`, leaving `num_as_str` on the stack.
/// let num_as_int: Option<uint> = num_as_str.as_ref().map(|n| n.len());
- /// println!("still can print num_as_str: {}", num_as_str);
+ /// println!("still can print num_as_str: {:?}", num_as_str);
/// ```
#[inline]
#[stable]
//! ```
// Reexported core operators
-pub use kinds::{Copy, Send, Sized, Sync};
-pub use ops::{Drop, Fn, FnMut, FnOnce};
+pub use marker::{Copy, Send, Sized, Sync};
+pub use ops::{Drop, Fn, FnMut, FnOnce, FullRange};
// Reexported functions
pub use iter::range;
use clone::Clone;
use intrinsics;
use option::Option::{self, Some, None};
-use kinds::{Send, Sized, Sync};
+use marker::{Send, Sized, Sync};
use cmp::{PartialEq, Eq, Ord, PartialOrd};
use cmp::Ordering::{self, Less, Equal, Greater};
//!
//! Their definition should always match the ABI defined in `rustc::back::abi`.
-use kinds::Copy;
+use marker::Copy;
use mem;
/// The representation of a Rust slice
//! let version = parse_version(&[1, 2, 3, 4]);
//! match version {
//! Ok(v) => {
-//! println!("working with version: {}", v);
+//! println!("working with version: {:?}", v);
//! }
//! Err(e) => {
-//! println!("error parsing header: {}", e);
+//! println!("error parsing header: {:?}", e);
//! }
//! }
//! ```
match self {
Ok(t) => t,
Err(e) =>
- panic!("called `Result::unwrap()` on an `Err` value: {}", e)
+ panic!("called `Result::unwrap()` on an `Err` value: {:?}", e)
}
}
}
pub fn unwrap_err(self) -> E {
match self {
Ok(t) =>
- panic!("called `Result::unwrap_err()` on an `Ok` value: {}", t),
+ panic!("called `Result::unwrap_err()` on an `Ok` value: {:?}", t),
Err(e) => e
}
}
//! use std::simd::f32x4;
//! let a = f32x4(40.0, 41.0, 42.0, 43.0);
//! let b = f32x4(1.0, 1.1, 3.4, 9.8);
-//! println!("{}", a + b);
+//! println!("{:?}", a + b);
//! }
//! ```
//!
use cmp;
use default::Default;
use iter::*;
-use kinds::Copy;
+use marker::Copy;
use num::Int;
-use ops::{FnMut, self};
+use ops::{FnMut, self, Index};
use option::Option;
use option::Option::{None, Some};
use result::Result;
use ptr::PtrExt;
use mem;
use mem::size_of;
-use kinds::{Sized, marker};
+use marker::{Sized, self};
use raw::Repr;
// Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module.
use raw::Slice as RawSlice;
#[inline]
fn split_at(&self, mid: uint) -> (&[T], &[T]) {
- (self[..mid], self[mid..])
+ (self.index(&(0..mid)), self.index(&(mid..)))
}
#[inline]
}
#[inline]
- fn tail(&self) -> &[T] { self[1..] }
+ fn tail(&self) -> &[T] { self.index(&(1..)) }
#[inline]
fn init(&self) -> &[T] {
- self[..self.len() - 1]
+ self.index(&(0..(self.len() - 1)))
}
#[inline]
fn as_mut_slice(&mut self) -> &mut [T] { self }
fn slice_mut(&mut self, start: uint, end: uint) -> &mut [T] {
- ops::SliceMut::slice_or_fail_mut(self, &start, &end)
+ ops::IndexMut::index_mut(self, &ops::Range { start: start, end: end } )
}
#[inline]
fn slice_from_mut(&mut self, start: uint) -> &mut [T] {
- ops::SliceMut::slice_from_or_fail_mut(self, &start)
+ ops::IndexMut::index_mut(self, &ops::RangeFrom { start: start } )
}
#[inline]
fn slice_to_mut(&mut self, end: uint) -> &mut [T] {
- ops::SliceMut::slice_to_or_fail_mut(self, &end)
+ ops::IndexMut::index_mut(self, &ops::RangeTo { end: end } )
}
#[inline]
unsafe {
let self2: &mut [T] = mem::transmute_copy(&self);
- (ops::SliceMut::slice_to_or_fail_mut(self, &mid),
- ops::SliceMut::slice_from_or_fail_mut(self2, &mid))
+ (ops::IndexMut::index_mut(self, &ops::RangeTo { end: mid } ),
+ ops::IndexMut::index_mut(self2, &ops::RangeFrom { start: mid } ))
}
}
#[inline]
fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq {
let n = needle.len();
- self.len() >= n && needle == self[..n]
+ self.len() >= n && needle == self.index(&(0..n))
}
#[inline]
fn ends_with(&self, needle: &[T]) -> bool where T: PartialEq {
let (m, n) = (self.len(), needle.len());
- m >= n && needle == self[m-n..]
+ m >= n && needle == self.index(&((m-n)..))
}
#[unstable]
}
}
-impl<T> ops::Slice<uint, [T]> for [T] {
+impl<T> ops::Index<ops::Range<uint>> for [T] {
+ type Output = [T];
#[inline]
- fn as_slice_<'a>(&'a self) -> &'a [T] {
- self
- }
-
- #[inline]
- fn slice_from_or_fail<'a>(&'a self, start: &uint) -> &'a [T] {
- self.slice_or_fail(start, &self.len())
- }
-
- #[inline]
- fn slice_to_or_fail<'a>(&'a self, end: &uint) -> &'a [T] {
- self.slice_or_fail(&0, end)
- }
- #[inline]
- fn slice_or_fail<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] {
- assert!(*start <= *end);
- assert!(*end <= self.len());
+ fn index(&self, index: &ops::Range<uint>) -> &[T] {
+ assert!(index.start <= index.end);
+ assert!(index.end <= self.len());
unsafe {
transmute(RawSlice {
- data: self.as_ptr().offset(*start as int),
- len: (*end - *start)
+ data: self.as_ptr().offset(index.start as int),
+ len: index.end - index.start
})
}
}
}
-
-impl<T> ops::SliceMut<uint, [T]> for [T] {
+impl<T> ops::Index<ops::RangeTo<uint>> for [T] {
+ type Output = [T];
#[inline]
- fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] {
- self
+ fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
+ self.index(&ops::Range{ start: 0, end: index.end })
}
-
+}
+impl<T> ops::Index<ops::RangeFrom<uint>> for [T] {
+ type Output = [T];
#[inline]
- fn slice_from_or_fail_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] {
- let len = &self.len();
- self.slice_or_fail_mut(start, len)
+ fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
+ self.index(&ops::Range{ start: index.start, end: self.len() })
}
-
+}
+impl<T> ops::Index<ops::FullRange> for [T] {
+ type Output = [T];
#[inline]
- fn slice_to_or_fail_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] {
- self.slice_or_fail_mut(&0, end)
+ fn index(&self, _index: &ops::FullRange) -> &[T] {
+ self
}
+}
+
+impl<T> ops::IndexMut<ops::Range<uint>> for [T] {
+ type Output = [T];
#[inline]
- fn slice_or_fail_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] {
- assert!(*start <= *end);
- assert!(*end <= self.len());
+ fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
+ assert!(index.start <= index.end);
+ assert!(index.end <= self.len());
unsafe {
transmute(RawSlice {
- data: self.as_ptr().offset(*start as int),
- len: (*end - *start)
+ data: self.as_ptr().offset(index.start as int),
+ len: index.end - index.start
})
}
}
}
+impl<T> ops::IndexMut<ops::RangeTo<uint>> for [T] {
+ type Output = [T];
+ #[inline]
+ fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
+ self.index_mut(&ops::Range{ start: 0, end: index.end })
+ }
+}
+impl<T> ops::IndexMut<ops::RangeFrom<uint>> for [T] {
+ type Output = [T];
+ #[inline]
+ fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
+ let len = self.len();
+ self.index_mut(&ops::Range{ start: index.start, end: len })
+ }
+}
+impl<T> ops::IndexMut<ops::FullRange> for [T] {
+ type Output = [T];
+ #[inline]
+ fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {
+ self
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
// Common traits
}
macro_rules! make_slice {
- ($t: ty -> $result: ty: $start: expr, $end: expr) => {{
+ ($t: ty => $result: ty: $start: expr, $end: expr) => {{
let diff = $end as uint - $start as uint;
let len = if mem::size_of::<T>() == 0 {
diff
}
#[experimental]
-impl<'a, T> ops::Slice<uint, [T]> for Iter<'a, T> {
- fn as_slice_(&self) -> &[T] {
- self.as_slice()
+impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, index: &ops::Range<uint>) -> &[T] {
+ self.as_slice().index(index)
}
- fn slice_from_or_fail<'b>(&'b self, from: &uint) -> &'b [T] {
- use ops::Slice;
- self.as_slice().slice_from_or_fail(from)
+}
+
+#[experimental]
+impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
+ self.as_slice().index(index)
}
- fn slice_to_or_fail<'b>(&'b self, to: &uint) -> &'b [T] {
- use ops::Slice;
- self.as_slice().slice_to_or_fail(to)
+}
+
+#[experimental]
+impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
+ self.as_slice().index(index)
}
- fn slice_or_fail<'b>(&'b self, from: &uint, to: &uint) -> &'b [T] {
- use ops::Slice;
- self.as_slice().slice_or_fail(from, to)
+}
+
+#[experimental]
+impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, _index: &ops::FullRange) -> &[T] {
+ self.as_slice()
}
}
/// iterator can continue to be used while this exists.
#[experimental]
pub fn as_slice(&self) -> &'a [T] {
- make_slice!(T -> &'a [T]: self.ptr, self.end)
+ make_slice!(T => &'a [T]: self.ptr, self.end)
}
}
marker: marker::ContravariantLifetime<'a>,
}
+
#[experimental]
-impl<'a, T> ops::Slice<uint, [T]> for IterMut<'a, T> {
- fn as_slice_<'b>(&'b self) -> &'b [T] {
- make_slice!(T -> &'b [T]: self.ptr, self.end)
+impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, index: &ops::Range<uint>) -> &[T] {
+ self.index(&ops::FullRange).index(index)
}
- fn slice_from_or_fail<'b>(&'b self, from: &uint) -> &'b [T] {
- use ops::Slice;
- self.as_slice_().slice_from_or_fail(from)
+}
+#[experimental]
+impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
+ self.index(&ops::FullRange).index(index)
}
- fn slice_to_or_fail<'b>(&'b self, to: &uint) -> &'b [T] {
- use ops::Slice;
- self.as_slice_().slice_to_or_fail(to)
+}
+#[experimental]
+impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
+ self.index(&ops::FullRange).index(index)
}
- fn slice_or_fail<'b>(&'b self, from: &uint, to: &uint) -> &'b [T] {
- use ops::Slice;
- self.as_slice_().slice_or_fail(from, to)
+}
+#[experimental]
+impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index(&self, _index: &ops::FullRange) -> &[T] {
+ make_slice!(T => &[T]: self.ptr, self.end)
}
}
#[experimental]
-impl<'a, T> ops::SliceMut<uint, [T]> for IterMut<'a, T> {
- fn as_mut_slice_<'b>(&'b mut self) -> &'b mut [T] {
- make_slice!(T -> &'b mut [T]: self.ptr, self.end)
+impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
+ self.index_mut(&ops::FullRange).index_mut(index)
}
- fn slice_from_or_fail_mut<'b>(&'b mut self, from: &uint) -> &'b mut [T] {
- use ops::SliceMut;
- self.as_mut_slice_().slice_from_or_fail_mut(from)
+}
+#[experimental]
+impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
+ self.index_mut(&ops::FullRange).index_mut(index)
}
- fn slice_to_or_fail_mut<'b>(&'b mut self, to: &uint) -> &'b mut [T] {
- use ops::SliceMut;
- self.as_mut_slice_().slice_to_or_fail_mut(to)
+}
+#[experimental]
+impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
+ self.index_mut(&ops::FullRange).index_mut(index)
}
- fn slice_or_fail_mut<'b>(&'b mut self, from: &uint, to: &uint) -> &'b mut [T] {
- use ops::SliceMut;
- self.as_mut_slice_().slice_or_fail_mut(from, to)
+}
+#[experimental]
+impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {
+ type Output = [T];
+ #[inline]
+ fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {
+ make_slice!(T => &mut [T]: self.ptr, self.end)
}
}
+
impl<'a, T> IterMut<'a, T> {
/// View the underlying data as a subslice of the original data.
///
/// restricted lifetimes that do not consume the iterator.
#[experimental]
pub fn into_slice(self) -> &'a mut [T] {
- make_slice!(T -> &'a mut [T]: self.ptr, self.end)
+ make_slice!(T => &'a mut [T]: self.ptr, self.end)
}
}
trait SplitIter: DoubleEndedIterator {
/// Mark the underlying iterator as complete, extracting the remaining
/// portion of the slice.
- fn finish(&mut self) -> Option< <Self as Iterator>::Item>;
+ fn finish(&mut self) -> Option<Self::Item>;
}
/// An iterator over subslices separated by elements that match a predicate
match self.v.iter().position(|x| (self.pred)(x)) {
None => self.finish(),
Some(idx) => {
- let ret = Some(self.v[..idx]);
- self.v = self.v[idx + 1..];
+ let ret = Some(self.v.index(&(0..idx)));
+ self.v = self.v.index(&((idx + 1)..));
ret
}
}
match self.v.iter().rposition(|x| (self.pred)(x)) {
None => self.finish(),
Some(idx) => {
- let ret = Some(self.v[idx + 1..]);
- self.v = self.v[..idx];
+ let ret = Some(self.v.index(&((idx + 1)..)));
+ self.v = self.v.index(&(0..idx));
ret
}
}
invert: bool
}
-impl<T, I: SplitIter + Iterator<Item=T>> Iterator for GenericSplitN<I> {
+impl<T, I: SplitIter<Item=T>> Iterator for GenericSplitN<I> {
type Item = T;
#[inline]
if self.size > self.v.len() {
None
} else {
- let ret = Some(self.v[..self.size]);
- self.v = self.v[1..];
+ let ret = Some(self.v.index(&(0..self.size)));
+ self.v = self.v.index(&(1..));
ret
}
}
let mut hi = lo + self.size;
if hi < lo || hi > self.v.len() { hi = self.v.len(); }
- Some(self.v[lo..hi])
+ Some(self.v.index(&(lo..hi)))
} else {
None
}
use iter::range;
use iter::ExactSizeIterator;
use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
-use kinds::Sized;
+use marker::Sized;
use mem;
use num::Int;
-use ops::{Fn, FnMut};
+use ops::{Fn, FnMut, Index};
use option::Option::{self, None, Some};
use ptr::PtrExt;
use raw::{Repr, Slice};
use uint;
macro_rules! delegate_iter {
- (exact $te:ty in $ti:ty) => {
- delegate_iter!{$te in $ti}
- #[stable]
+ (exact $te:ty : $ti:ty) => {
+ delegate_iter!{$te : $ti}
impl<'a> ExactSizeIterator for $ti {
#[inline]
fn len(&self) -> uint {
}
}
};
- ($te:ty in $ti:ty) => {
+ ($te:ty : $ti:ty) => {
#[stable]
impl<'a> Iterator for $ti {
type Item = $te;
}
}
};
- (pattern $te:ty in $ti:ty) => {
+ (pattern $te:ty : $ti:ty) => {
#[stable]
impl<'a, P: CharEq> Iterator for $ti {
type Item = $te;
}
}
};
- (pattern forward $te:ty in $ti:ty) => {
+ (pattern forward $te:ty : $ti:ty) => {
#[stable]
impl<'a, P: CharEq> Iterator for $ti {
type Item = $te;
*/
/// Errors which can occur when attempting to interpret a byte slice as a `str`.
-#[derive(Copy, Eq, PartialEq, Clone)]
+#[derive(Copy, Eq, PartialEq, Clone, Show)]
#[unstable = "error enumeration recently added and definitions may be refined"]
pub enum Utf8Error {
/// An invalid byte was detected at the byte offset given.
#[stable]
#[derive(Clone)]
pub struct Bytes<'a>(Map<&'a u8, u8, slice::Iter<'a, u8>, BytesDeref>);
-delegate_iter!{exact u8 in Bytes<'a>}
+delegate_iter!{exact u8 : Bytes<'a>}
/// A temporary fn new type that ensures that the `Bytes` iterator
/// is cloneable.
fn next(&mut self, haystack: &[u8], needle: &[u8]) -> Option<(uint, uint)> {
while self.position + needle.len() <= haystack.len() {
- if haystack[self.position .. self.position + needle.len()] == needle {
+ if haystack.index(&(self.position .. self.position + needle.len())) == needle {
let match_pos = self.position;
self.position += needle.len(); // add 1 for all matches
return Some((match_pos, match_pos + needle.len()));
//
// What's going on is we have some critical factorization (u, v) of the
// needle, and we want to determine whether u is a suffix of
- // v[..period]. If it is, we use "Algorithm CP1". Otherwise we use
+ // v.index(&(0..period)). If it is, we use "Algorithm CP1". Otherwise we use
// "Algorithm CP2", which is optimized for when the period of the needle
// is large.
- if needle[..crit_pos] == needle[period.. period + crit_pos] {
+ if needle.index(&(0..crit_pos)) == needle.index(&(period.. period + crit_pos)) {
TwoWaySearcher {
crit_pos: crit_pos,
period: period,
}
}
- impl ops::Slice<uint, str> for str {
+ impl ops::Index<ops::Range<uint>> for str {
+ type Output = str;
#[inline]
- fn as_slice_<'a>(&'a self) -> &'a str {
- self
+ fn index(&self, index: &ops::Range<uint>) -> &str {
+ self.slice(index.start, index.end)
}
-
+ }
+ impl ops::Index<ops::RangeTo<uint>> for str {
+ type Output = str;
#[inline]
- fn slice_from_or_fail<'a>(&'a self, from: &uint) -> &'a str {
- self.slice_from(*from)
+ fn index(&self, index: &ops::RangeTo<uint>) -> &str {
+ self.slice_to(index.end)
}
-
+ }
+ impl ops::Index<ops::RangeFrom<uint>> for str {
+ type Output = str;
#[inline]
- fn slice_to_or_fail<'a>(&'a self, to: &uint) -> &'a str {
- self.slice_to(*to)
+ fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
+ self.slice_from(index.start)
}
-
+ }
+ impl ops::Index<ops::FullRange> for str {
+ type Output = str;
#[inline]
- fn slice_or_fail<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
- self.slice(*from, *to)
+ fn index(&self, _index: &ops::FullRange) -> &str {
+ self
}
}
}
#[derive(Clone)]
#[stable]
pub struct Split<'a, P>(CharSplits<'a, P>);
-delegate_iter!{pattern &'a str in Split<'a, P>}
+delegate_iter!{pattern &'a str : Split<'a, P>}
/// Return type of `StrExt::split_terminator`
#[derive(Clone)]
#[unstable = "might get removed in favour of a constructor method on Split"]
pub struct SplitTerminator<'a, P>(CharSplits<'a, P>);
-delegate_iter!{pattern &'a str in SplitTerminator<'a, P>}
+delegate_iter!{pattern &'a str : SplitTerminator<'a, P>}
/// Return type of `StrExt::splitn`
#[derive(Clone)]
#[stable]
pub struct SplitN<'a, P>(CharSplitsN<'a, P>);
-delegate_iter!{pattern forward &'a str in SplitN<'a, P>}
+delegate_iter!{pattern forward &'a str : SplitN<'a, P>}
/// Return type of `StrExt::rsplitn`
#[derive(Clone)]
#[stable]
pub struct RSplitN<'a, P>(CharSplitsN<'a, P>);
-delegate_iter!{pattern forward &'a str in RSplitN<'a, P>}
+delegate_iter!{pattern forward &'a str : RSplitN<'a, P>}
/// Methods for string slices
#[allow(missing_docs)]
#[inline]
fn starts_with(&self, needle: &str) -> bool {
let n = needle.len();
- self.len() >= n && needle.as_bytes() == self.as_bytes()[..n]
+ self.len() >= n && needle.as_bytes() == self.as_bytes().index(&(0..n))
}
#[inline]
fn ends_with(&self, needle: &str) -> bool {
let (m, n) = (self.len(), needle.len());
- m >= n && needle.as_bytes() == self.as_bytes()[m-n..]
+ m >= n && needle.as_bytes() == self.as_bytes().index(&((m-n)..))
}
#[inline]
//! Types dealing with unsafe actions.
-use kinds::marker;
+use marker;
match a.downcast_ref::<uint>() {
Some(&5) => {}
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
match a.downcast_ref::<Test>() {
None => {}
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
}
assert_eq!(*x, 5u);
*x = 612;
}
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
match b_r.downcast_mut::<uint>() {
assert_eq!(*x, 7u);
*x = 413;
}
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
match a_r.downcast_mut::<Test>() {
None => (),
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
match b_r.downcast_mut::<Test>() {
None => (),
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
match a_r.downcast_mut::<uint>() {
Some(&612) => {}
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
match b_r.downcast_mut::<uint>() {
Some(&413) => {}
- x => panic!("Unexpected value {}", x)
+ x => panic!("Unexpected value {:?}", x)
}
}
#[test]
fn cell_has_sensible_show() {
let x = Cell::new("foo bar");
- assert!(format!("{}", x).contains(x.get()));
+ assert!(format!("{:?}", x).contains(x.get()));
x.set("baz qux");
- assert!(format!("{}", x).contains(x.get()));
+ assert!(format!("{:?}", x).contains(x.get()));
}
#[test]
let refcell = RefCell::new("foo");
let refcell_refmut = refcell.borrow_mut();
- assert!(format!("{}", refcell_refmut).contains("foo"));
+ assert!(format!("{:?}", refcell_refmut).contains("foo"));
drop(refcell_refmut);
let refcell_ref = refcell.borrow();
- assert!(format!("{}", refcell_ref).contains("foo"));
+ assert!(format!("{:?}", refcell_ref).contains("foo"));
drop(refcell_ref);
}
fn check(input: char, expect: &[u8]) {
let mut buf = [0u8; 4];
let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
- assert_eq!(buf[..n], expect);
+ assert_eq!(buf.index(&(0..n)), expect);
}
check('x', &[0x78]);
fn check(input: char, expect: &[u16]) {
let mut buf = [0u16; 2];
let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
- assert_eq!(buf[..n], expect);
+ assert_eq!(buf.index(&(0..n)), expect);
}
check('x', &[0x0078]);
assert!(format!("{}", -1i16) == "-1");
assert!(format!("{}", -1i32) == "-1");
assert!(format!("{}", -1i64) == "-1");
+ assert!(format!("{:?}", 1i) == "1i");
+ assert!(format!("{:?}", 1i8) == "1i8");
+ assert!(format!("{:?}", 1i16) == "1i16");
+ assert!(format!("{:?}", 1i32) == "1i32");
+ assert!(format!("{:?}", 1i64) == "1i64");
assert!(format!("{:b}", 1i) == "1");
assert!(format!("{:b}", 1i8) == "1");
assert!(format!("{:b}", 1i16) == "1");
assert!(format!("{}", 1u16) == "1");
assert!(format!("{}", 1u32) == "1");
assert!(format!("{}", 1u64) == "1");
+ assert!(format!("{:?}", 1u) == "1u");
+ assert!(format!("{:?}", 1u8) == "1u8");
+ assert!(format!("{:?}", 1u16) == "1u16");
+ assert!(format!("{:?}", 1u32) == "1u32");
+ assert!(format!("{:?}", 1u64) == "1u64");
assert!(format!("{:b}", 1u) == "1");
assert!(format!("{:b}", 1u8) == "1");
assert!(format!("{:b}", 1u16) == "1");
#[test]
fn test_format_int_zero() {
assert!(format!("{}", 0i) == "0");
+ assert!(format!("{:?}", 0i) == "0i");
assert!(format!("{:b}", 0i) == "0");
assert!(format!("{:o}", 0i) == "0");
assert!(format!("{:x}", 0i) == "0");
assert!(format!("{:X}", 0i) == "0");
assert!(format!("{}", 0u) == "0");
+ assert!(format!("{:?}", 0u) == "0u");
assert!(format!("{:b}", 0u) == "0");
assert!(format!("{:o}", 0u) == "0");
assert!(format!("{:x}", 0u) == "0");
b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
}
+ #[bench]
+ fn format_show(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| { format!("{:?}", rng.gen::<uint>()); })
+ }
+
#[bench]
fn format_base_36(b: &mut Bencher) {
let mut rng = weak_rng();
b.iter(|| { format!("{:x}", rng.gen::<int>()); })
}
+ #[bench]
+ fn format_show(b: &mut Bencher) {
+ let mut rng = weak_rng();
+ b.iter(|| { format!("{:?}", rng.gen::<int>()); })
+ }
+
#[bench]
fn format_base_36(b: &mut Bencher) {
let mut rng = weak_rng();
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use core::kinds::Sized;
+use core::marker::Sized;
use std::mem;
use core::slice::SliceExt;
use core::num::SignedInt;
use core::uint;
use core::cmp;
-use core::ops::Slice;
use test::Bencher;
.collect::<Vec<uint>>();
assert_eq!(n, xs.len());
- assert_eq!(xs[], ys[]);
+ assert_eq!(&xs[], &ys[]);
}
#[test]
fn test_iterator_last() {
let v: &[_] = &[0i, 1, 2, 3, 4];
assert_eq!(v.iter().last().unwrap(), &4);
- assert_eq!(v[0..1].iter().last().unwrap(), &0);
+ assert_eq!(v[..1].iter().last().unwrap(), &0);
}
#[test]
fn test_iterator_len() {
let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- assert_eq!(v[0..4].iter().count(), 4);
- assert_eq!(v[0..10].iter().count(), 10);
+ assert_eq!(v[..4].iter().count(), 4);
+ assert_eq!(v[..10].iter().count(), 10);
assert_eq!(v[0..0].iter().count(), 0);
}
#[test]
fn test_iterator_sum() {
let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- assert_eq!(v[0..4].iter().map(|&x| x).sum(), 6);
+ assert_eq!(v[..4].iter().map(|&x| x).sum(), 6);
assert_eq!(v.iter().map(|&x| x).sum(), 55);
assert_eq!(v[0..0].iter().map(|&x| x).sum(), 0);
}
assert!(v.iter().all(|&x| x < 10));
assert!(!v.iter().all(|&x| x % 2 == 0));
assert!(!v.iter().all(|&x| x > 100));
- assert!(v.slice_or_fail(&0, &0).iter().all(|_| panic!()));
+ assert!(v[0..0].iter().all(|_| panic!()));
}
#[test]
assert!(v.iter().any(|&x| x < 10));
assert!(v.iter().any(|&x| x % 2 == 0));
assert!(!v.iter().any(|&x| x > 100));
- assert!(!v.slice_or_fail(&0, &0).iter().any(|_| panic!()));
+ assert!(!v[0..0].iter().any(|_| panic!()));
}
#[test]
fn test_double_ended_flat_map() {
let u = [0u,1];
let v = [5u,6,7,8];
- let mut it = u.iter().flat_map(|x| v[*x..v.len()].iter());
+ let mut it = u.iter().flat_map(|x| v[(*x)..v.len()].iter());
assert_eq!(it.next_back().unwrap(), &8);
assert_eq!(it.next().unwrap(), &5);
assert_eq!(it.next_back().unwrap(), &7);
use core::fmt::Show;
use core::num::{NumCast, cast};
use core::ops::{Add, Sub, Mul, Div, Rem};
-use core::kinds::Copy;
+use core::marker::Copy;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod int_macros;
mod i8;
mod i64;
mod int;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod uint_macros;
mod u8;
// except according to those terms.
use core::option::*;
-use core::kinds::marker;
+use core::marker;
use core::mem;
use core::clone::Clone;
let ok: Result<int, &'static str> = Ok(100);
let err: Result<int, &'static str> = Err("Err");
- let s = format!("{}", ok);
- assert_eq!(s, "Ok(100)");
- let s = format!("{}", err);
- assert_eq!(s, "Err(Err)");
+ let s = format!("{:?}", ok);
+ assert_eq!(s, "Ok(100i)");
+ let s = format!("{:?}", err);
+ assert_eq!(s, "Err(\"Err\")");
}
#[test]
{
let mut iter = data.iter();
- assert_eq!(iter[], other_data[]);
+ assert_eq!(&iter[], &other_data[]);
iter.next();
- assert_eq!(iter[], other_data[1..]);
+ assert_eq!(&iter[], &other_data[1..]);
iter.next_back();
- assert_eq!(iter[], other_data[1..2]);
+ assert_eq!(&iter[], &other_data[1..2]);
let s = iter.as_slice();
iter.next();
- assert_eq!(s, other_data[1..2]);
+ assert_eq!(s, &other_data[1..2]);
}
{
let mut iter = data.iter_mut();
- assert_eq!(iter[], other_data[]);
+ assert_eq!(iter.index(&FullRange), other_data.index(&FullRange));
// mutability:
- assert!(iter[mut] == other_data);
+ assert!(&mut iter[] == other_data);
iter.next();
- assert_eq!(iter[], other_data[1..]);
- assert!(iter[mut] == other_data[mut 1..]);
+ assert_eq!(iter.index(&FullRange), other_data.index(&(1..)));
+ assert!(&mut iter[] == &mut other_data[1..]);
iter.next_back();
- assert_eq!(iter[], other_data[1..2]);
- assert!(iter[mut] == other_data[mut 1..2]);
+ assert_eq!(iter.index(&FullRange), other_data.index(&(1..2)));
+ assert!(&mut iter[] == &mut other_data[1..2]);
let s = iter.into_slice();
- assert!(s == other_data[mut 1..2]);
+ assert!(s == &mut other_data[1..2]);
}
}}
}
#[test]
fn test_show() {
- let s = format!("{}", (1i,));
- assert_eq!(s, "(1,)");
- let s = format!("{}", (1i, true));
- assert_eq!(s, "(1, true)");
- let s = format!("{}", (1i, "hi", true));
- assert_eq!(s, "(1, hi, true)");
+ let s = format!("{:?}", (1i,));
+ assert_eq!(s, "(1i,)");
+ let s = format!("{:?}", (1i, true));
+ assert_eq!(s, "(1i, true)");
+ let s = format!("{:?}", (1i, "hi", true));
+ assert_eq!(s, "(1i, \"hi\", true)");
}
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(unboxed_closures, associated_types)]
#[cfg(test)] #[macro_use] extern crate log;
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(globs, slicing_syntax)]
-#![feature(associated_types)]
+#![feature(slicing_syntax)]
pub use self::Piece::*;
pub use self::Position::*;
self.cur.next();
}
Some((_, other)) => {
- self.err(format!("expected `{}`, found `{}`", c, other)[]);
+ self.err(format!("expected `{:?}`, found `{:?}`", c,
+ other).index(&FullRange));
}
None => {
- self.err(format!("expected `{}` but string was terminated",
- c)[]);
+ self.err(format!("expected `{:?}` but string was terminated",
+ c).index(&FullRange));
}
}
}
// we may not consume the character, so clone the iterator
match self.cur.clone().next() {
Some((pos, '}')) | Some((pos, '{')) => {
- return self.input[start..pos];
+ return self.input.index(&(start..pos));
}
Some(..) => { self.cur.next(); }
None => {
self.cur.next();
- return self.input[start..self.input.len()];
+ return self.input.index(&(start..self.input.len()));
}
}
}
flags: 0,
precision: CountImplied,
width: CountImplied,
- ty: self.input[0..0],
+ ty: self.input.index(&(0..0)),
};
if !self.consume(':') { return spec }
self.cur.next();
pos
}
- Some(..) | None => { return self.input[0..0]; }
+ Some(..) | None => { return self.input.index(&(0..0)); }
};
let mut end;
loop {
None => { end = self.input.len(); break }
}
}
- self.input[start..end]
+ self.input.index(&(start..end))
}
/// Optionally parses an integer at the current position. This doesn't deal
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(globs, slicing_syntax)]
-#![feature(unboxed_closures)]
+#![feature(slicing_syntax)]
#![deny(missing_docs)]
#[cfg(test)] #[macro_use] extern crate log;
use std::result;
/// Name of an option. Either a string or a single char.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
pub enum Name {
/// A string representing the long name of an option.
/// For example: "help"
}
/// Describes whether an option has an argument.
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq, Show)]
pub enum HasArg {
/// The option requires an argument.
Yes,
}
/// Describes how often an option may occur.
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq, Show)]
pub enum Occur {
/// The option occurs once.
Req,
}
/// A description of a possible option.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
pub struct Opt {
/// Name of the option
pub name: Name,
/// One group of options, e.g., both `-h` and `--help`, along with
/// their shared description and properties.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
pub struct OptGroup {
/// Short name of the option, e.g. `h` for a `-h` option
pub short_name: String,
}
/// Describes whether an option is given at all or has a value.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
enum Optval {
Val(String),
Given,
/// The result of checking command line arguments. Contains a vector
/// of matches and a vector of free strings.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
pub struct Matches {
/// Options that matched
opts: Vec<Opt>,
/// The type returned when the command line does not conform to the
/// expected format. Use the `Show` implementation to output detailed
/// information.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
pub enum Fail {
/// The option requires an argument but none was passed.
ArgumentMissing(String),
}
/// The type of failure that occurred.
-#[derive(Copy, PartialEq, Eq)]
+#[derive(Copy, PartialEq, Eq, Show)]
#[allow(missing_docs)]
pub enum FailType {
ArgumentMissing_,
impl Matches {
fn opt_vals(&self, nm: &str) -> Vec<Optval> {
- match find_opt(self.opts[], Name::from_str(nm)) {
+ match find_opt(self.opts.index(&FullRange), Name::from_str(nm)) {
Some(id) => self.vals[id].clone(),
None => panic!("No option '{}' defined", nm)
}
/// Returns true if any of several options were matched.
pub fn opts_present(&self, names: &[String]) -> bool {
for nm in names.iter() {
- match find_opt(self.opts.as_slice(), Name::from_str(nm[])) {
+ match find_opt(self.opts.as_slice(), Name::from_str(nm.index(&FullRange))) {
Some(id) if !self.vals[id].is_empty() => return true,
_ => (),
};
/// Returns the string argument supplied to one of several matching options or `None`.
pub fn opts_str(&self, names: &[String]) -> Option<String> {
for nm in names.iter() {
- match self.opt_val(nm[]) {
+ match self.opt_val(nm.index(&FullRange)) {
Some(Val(ref s)) => return Some(s.clone()),
_ => ()
}
impl Fail {
/// Convert a `Fail` enum into an error string.
- #[deprecated="use `Show` (`{}` format specifier)"]
+ #[deprecated="use `fmt::String` (`{}` format specifier)"]
pub fn to_err_msg(self) -> String {
self.to_string()
}
}
-impl fmt::Show for Fail {
+impl fmt::String for Fail {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ArgumentMissing(ref nm) => {
while i < l {
let cur = args[i].clone();
let curlen = cur.len();
- if !is_arg(cur[]) {
+ if !is_arg(cur.index(&FullRange)) {
free.push(cur);
} else if cur == "--" {
let mut j = i + 1;
let mut names;
let mut i_arg = None;
if cur.as_bytes()[1] == b'-' {
- let tail = cur[2..curlen];
+ let tail = cur.index(&(2..curlen));
let tail_eq: Vec<&str> = tail.split('=').collect();
if tail_eq.len() <= 1 {
names = vec!(Long(tail.to_string()));
};
if arg_follows && range.next < curlen {
- i_arg = Some(cur[range.next..curlen].to_string());
+ i_arg = Some(cur.index(&(range.next..curlen)).to_string());
break;
}
if name_pos == names.len() && !i_arg.is_none() {
return Err(UnexpectedArgument(nm.to_string()));
}
- vals[optid].push(Given);
+ let v = &mut vals[optid];
+ v.push(Given);
}
Maybe => {
if !i_arg.is_none() {
- vals[optid]
- .push(Val((i_arg.clone())
+ let v = &mut vals[optid];
+ v.push(Val((i_arg.clone())
.unwrap()));
} else if name_pos < names.len() || i + 1 == l ||
- is_arg(args[i + 1][]) {
- vals[optid].push(Given);
+ is_arg(args[i + 1].index(&FullRange)) {
+ let v = &mut vals[optid];
+ v.push(Given);
} else {
i += 1;
- vals[optid].push(Val(args[i].clone()));
+ let v = &mut vals[optid];
+ v.push(Val(args[i].clone()));
}
}
Yes => {
if !i_arg.is_none() {
- vals[optid].push(Val(i_arg.clone().unwrap()));
+ let v = &mut vals[optid];
+ v.push(Val(i_arg.clone().unwrap()));
} else if i + 1 == l {
return Err(ArgumentMissing(nm.to_string()));
} else {
i += 1;
- vals[optid].push(Val(args[i].clone()));
+ let v = &mut vals[optid];
+ v.push(Val(args[i].clone()));
}
}
}
0 => {}
1 => {
row.push('-');
- row.push_str(short_name[]);
+ row.push_str(short_name.index(&FullRange));
row.push(' ');
}
_ => panic!("the short name should only be 1 ascii char long"),
0 => {}
_ => {
row.push_str("--");
- row.push_str(long_name[]);
+ row.push_str(long_name.index(&FullRange));
row.push(' ');
}
}
// arg
match hasarg {
No => {}
- Yes => row.push_str(hint[]),
+ Yes => row.push_str(hint.index(&FullRange)),
Maybe => {
row.push('[');
- row.push_str(hint[]);
+ row.push_str(hint.index(&FullRange));
row.push(']');
}
}
row.push(' ');
}
} else {
- row.push_str(desc_sep[]);
+ row.push_str(desc_sep.index(&FullRange));
}
// Normalize desc to contain words separated by one space character
// FIXME: #5516 should be graphemes not codepoints
let mut desc_rows = Vec::new();
- each_split_within(desc_normalized_whitespace[], 54, |substr| {
+ each_split_within(desc_normalized_whitespace.index(&FullRange), 54, |substr| {
desc_rows.push(substr.to_string());
true
});
// FIXME: #5516 should be graphemes not codepoints
// wrapped description
- row.push_str(desc_rows.connect(desc_sep[])[]);
+ row.push_str(desc_rows.connect(desc_sep.index(&FullRange)).index(&FullRange));
row
});
// Use short_name is possible, but fallback to long_name.
if opt.short_name.len() > 0 {
line.push('-');
- line.push_str(opt.short_name[]);
+ line.push_str(opt.short_name.index(&FullRange));
} else {
line.push_str("--");
- line.push_str(opt.long_name[]);
+ line.push_str(opt.long_name.index(&FullRange));
}
if opt.hasarg != No {
if opt.hasarg == Maybe {
line.push('[');
}
- line.push_str(opt.hint[]);
+ line.push_str(opt.hint.index(&FullRange));
if opt.hasarg == Maybe {
line.push(']');
}
line.push_str(opts.iter()
.map(format_option)
.collect::<Vec<String>>()
- .connect(" ")[]);
+ .connect(" ").index(&FullRange));
line
}
(B, Cr, UnderLim) => { B }
(B, Cr, OverLim) if (i - last_start + 1) > lim
=> panic!("word starting with {} longer than limit!",
- ss[last_start..i + 1]),
+ ss.index(&(last_start..(i + 1)))),
(B, Cr, OverLim) => {
- *cont = it(ss[slice_start..last_end]);
+ *cont = it(ss.index(&(slice_start..last_end)));
slice_start = last_start;
B
}
}
(B, Ws, OverLim) => {
last_end = i;
- *cont = it(ss[slice_start..last_end]);
+ *cont = it(ss.index(&(slice_start..last_end)));
A
}
B
}
(C, Cr, OverLim) => {
- *cont = it(ss[slice_start..last_end]);
+ *cont = it(ss.index(&(slice_start..last_end)));
slice_start = i;
last_start = i;
last_end = i;
B
}
(C, Ws, OverLim) => {
- *cont = it(ss[slice_start..last_end]);
+ *cont = it(ss.index(&(slice_start..last_end)));
A
}
(C, Ws, UnderLim) => {
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(globs, slicing_syntax)]
-#![feature(unboxed_closures)]
+#![feature(slicing_syntax)]
use self::LabelText::*;
pub fn escape(&self) -> String {
match self {
&LabelStr(ref s) => s.escape_default(),
- &EscStr(ref s) => LabelText::escape_str(s[]),
+ &EscStr(ref s) => LabelText::escape_str(s.index(&FullRange)),
}
}
let mut prefix = self.pre_escaped_content().into_owned();
let suffix = suffix.pre_escaped_content();
prefix.push_str(r"\n\n");
- prefix.push_str(suffix[]);
+ prefix.push_str(suffix.index(&FullRange));
EscStr(prefix.into_cow())
}
}
impl<'a> Labeller<'a, Node, &'a Edge> for LabelledGraph {
fn graph_id(&'a self) -> Id<'a> {
- Id::new(self.name[]).unwrap()
+ Id::new(self.name.index(&FullRange)).unwrap()
}
fn node_id(&'a self, n: &Node) -> Id<'a> {
id_name(n)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(globs)]
#![crate_name = "libc"]
-#![experimental]
-#![no_std] // we don't need std, and we can't have std, since it doesn't exist
- // yet. std depends on us.
#![crate_type = "rlib"]
+#![cfg_attr(not(feature = "cargo-build"), experimental)]
+#![no_std]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
//! in multiple derived systems. This is the 4.4BSD r2 / 1995 release, the final
//! one from Berkeley after the lawsuits died down and the CSRG dissolved.
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-#![allow(non_upper_case_globals)]
-#![allow(missing_docs)]
-#![allow(non_snake_case)]
-#![allow(raw_pointer_deriving)]
+#![allow(bad_style, raw_pointer_derive)]
-extern crate core;
+#[cfg(feature = "cargo-build")] extern crate "std" as core;
+#[cfg(not(feature = "cargo-build"))] extern crate core;
#[cfg(test)] extern crate std;
#[cfg(test)] extern crate test;
-pub use self::Nullable::*;
-
// Explicit export lists for the intersection (provided here) mean that
// you can write more-platform-agnostic code if you stick to just these
// symbols.
#[link(name = "m")]
extern {}
-/// A wrapper for a nullable pointer. Don't use this except for interacting
-/// with libc. Basically Option, but without the dependence on libstd.
-// If/when libprim happens, this can be removed in favor of that
-pub enum Nullable<T> {
- Null,
- NotNull(T)
-}
-
pub mod types {
// Types tend to vary *per architecture* so we pull their definitions out
extern {
pub fn glob(pattern: *const c_char,
flags: c_int,
- errfunc: ::Nullable<extern "C" fn(epath: *const c_char,
+ errfunc: ::core::option::Option<extern "C" fn(epath: *const c_char,
errno: c_int) -> c_int>,
pglob: *mut glob_t);
pub fn globfree(pglob: *mut glob_t);
#[doc(hidden)]
#[cfg(not(test))]
mod std {
- pub use core::kinds;
+ #[cfg(stage0)]
+ pub use core::marker as kinds;
+ pub use core::marker;
}
match Regex::new(filter) {
Ok(re) => Some(re),
Err(e) => {
- println!("warning: invalid regex filter - {}", e);
+ println!("warning: invalid regex filter - {:?}", e);
None
}
}
//! #[macro_use] extern crate log;
//!
//! fn main() {
-//! debug!("this is a debug {}", "message");
+//! debug!("this is a debug {:?}", "message");
//! error!("this is printed by default");
//!
//! if log_enabled!(log::INFO) {
//! let x = 3i * 4i; // expensive computation
-//! info!("the answer was: {}", x);
+//! info!("the answer was: {:?}", x);
//! }
//! }
//! ```
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, unboxed_closures, slicing_syntax)]
+#![feature(slicing_syntax)]
#![deny(missing_docs)]
extern crate regex;
use directive::LOG_LEVEL_NAMES;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod macros;
mod directive;
pub struct LogLevel(pub u32);
impl fmt::Show for LogLevel {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, fmt)
+ }
+}
+
+impl fmt::String for LogLevel {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let LogLevel(level) = *self;
match LOG_LEVEL_NAMES.get(level as uint - 1) {
- Some(name) => name.fmt(fmt),
- None => level.fmt(fmt)
+ Some(ref name) => fmt::String::fmt(name, fmt),
+ None => fmt::String::fmt(&level, fmt)
}
}
}
record.level,
record.module_path,
record.args) {
- Err(e) => panic!("failed to log: {}", e),
+ Err(e) => panic!("failed to log: {:?}", e),
Ok(()) => {}
}
}
fn drop(&mut self) {
// FIXME(#12628): is panicking the right thing to do?
match self.handle.flush() {
- Err(e) => panic!("failed to flush a logger: {}", e),
+ Err(e) => panic!("failed to flush a logger: {:?}", e),
Ok(()) => {}
}
}
// Test the literal string from args against the current filter, if there
// is one.
match unsafe { FILTER.as_ref() } {
- Some(filter) if !filter.is_match(args.to_string()[]) => return,
+ Some(filter) if !filter.is_match(args.to_string().index(&FullRange)) => return,
_ => {}
}
// Search for the longest match, the vector is assumed to be pre-sorted.
for directive in iter.rev() {
match directive.name {
- Some(ref name) if !module.starts_with(name[]) => {},
+ Some(ref name) if !module.starts_with(name.index(&FullRange)) => {},
Some(..) | None => {
return level <= directive.level
}
/// `Once` primitive (and this function is called from that primitive).
fn init() {
let (mut directives, filter) = match os::getenv("RUST_LOG") {
- Some(spec) => directive::parse_logging_spec(spec[]),
+ Some(spec) => directive::parse_logging_spec(spec.index(&FullRange)),
None => (Vec::new(), None),
};
// this is surprisingly complicated to be both generic & correct
-use core::prelude::*;
+use core::prelude::{PartialOrd};
use core::num::Int;
use Rng;
use std::num::Int;
use std::prelude::v1::*;
use distributions::{Sample, IndependentSample};
- use super::Range;
+ use super::Range as Range;
#[should_fail]
#[test]
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, phase, globs)]
-#![feature(unboxed_closures)]
-#![feature(associated_types)]
#![no_std]
#![experimental]
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate core;
-
-#[cfg(not(stage0))]
#[macro_use]
extern crate core;
-#[cfg(all(test, stage0))]
-#[phase(plugin, link)]
-extern crate std;
-
-#[cfg(all(test, not(stage0)))]
-#[macro_use]
-extern crate std;
-
-#[cfg(all(test, stage0))]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(all(test, not(stage0)))]
-#[macro_use]
-extern crate log;
+#[cfg(test)] #[macro_use] extern crate std;
+#[cfg(test)] #[macro_use] extern crate log;
use core::prelude::*;
///
/// let mut v = [0u8; 13579];
/// thread_rng().fill_bytes(&mut v);
- /// println!("{}", v.as_slice());
+ /// println!("{:?}", v.as_slice());
/// ```
fn fill_bytes(&mut self, dest: &mut [u8]) {
// this could, in theory, be done by transmuting dest to a
/// let mut rng = thread_rng();
/// let x: uint = rng.gen();
/// println!("{}", x);
- /// println!("{}", rng.gen::<(f64, bool)>());
+ /// println!("{:?}", rng.gen::<(f64, bool)>());
/// ```
#[inline(always)]
fn gen<T: Rand>(&mut self) -> T {
/// let mut rng = thread_rng();
/// let x = rng.gen_iter::<uint>().take(10).collect::<Vec<uint>>();
/// println!("{}", x);
- /// println!("{}", rng.gen_iter::<(f64, bool)>().take(5)
- /// .collect::<Vec<(f64, bool)>>());
+ /// println!("{:?}", rng.gen_iter::<(f64, bool)>().take(5)
+ /// .collect::<Vec<(f64, bool)>>());
/// ```
fn gen_iter<'a, T: Rand>(&'a mut self) -> Generator<'a, T, Self> {
Generator { rng: self }
///
/// let choices = [1i, 2, 4, 8, 16, 32];
/// let mut rng = thread_rng();
- /// println!("{}", rng.choose(&choices));
- /// # // replace with slicing syntax when it's stable!
- /// assert_eq!(rng.choose(choices.slice_to(0)), None);
+ /// println!("{:?}", rng.choose(&choices));
+ /// # // uncomment when slicing syntax is stable
+ /// //assert_eq!(rng.choose(choices.index(&(0..0))), None);
/// ```
fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
if values.is_empty() {
mod std {
pub use core::{option, fmt}; // panic!()
pub use core::clone; // derive Clone
- pub use core::kinds;
+ #[cfg(stage0)]
+ pub use core::marker as kinds;
+ pub use core::marker;
}
#[cfg(test)]
// there (left), and what will be appended on the end (right)
let cap = self.buf.len() - self.pos;
let (left, right) = if cap <= buf.len() {
- (buf[..cap], buf[cap..])
+ (buf.index(&(0..cap)), buf.index(&(cap..)))
} else {
let result: (_, &[_]) = (buf, &[]);
result
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
-#![feature(macro_rules, phase, slicing_syntax, globs)]
-#![feature(unboxed_closures, associated_types)]
-#![allow(missing_docs)]
+#![feature(slicing_syntax)]
extern crate serialize;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
+#[macro_use] extern crate log;
#[cfg(test)] extern crate test;
}
pub fn as_str_slice<'a>(&'a self) -> &'a str {
- str::from_utf8(self.data[self.start..self.end]).unwrap()
+ str::from_utf8(self.data.index(&(self.start..self.end))).unwrap()
}
pub fn as_str(&self) -> String {
match $e {
Ok(e) => e,
Err(e) => {
- debug!("ignored error: {}", e);
+ debug!("ignored error: {:?}", e);
return $r
}
}
match maybe_get_doc(d, tg) {
Some(d) => d,
None => {
- error!("failed to find block with tag {}", tg);
+ error!("failed to find block with tag {:?}", tg);
panic!();
}
}
pub fn with_doc_data<T, F>(d: Doc, f: F) -> T where
F: FnOnce(&[u8]) -> T,
{
- f(d.data[d.start..d.end])
+ f(d.data.index(&(d.start..d.end)))
}
self.pos = r_doc.end;
let str = r_doc.as_str_slice();
if lbl != str {
- return Err(Expected(format!("Expected label {} but \
- found {}", lbl, str)));
+ return Err(Expected(format!("Expected label {:?} but \
+ found {:?}", lbl, str)));
}
}
}
}
fn next_doc(&mut self, exp_tag: EbmlEncoderTag) -> DecodeResult<Doc<'doc>> {
- debug!(". next_doc(exp_tag={})", exp_tag);
+ debug!(". next_doc(exp_tag={:?})", exp_tag);
if self.pos >= self.parent.end {
return Err(Expected(format!("no more documents in \
current node!")));
}
let TaggedDoc { tag: r_tag, doc: r_doc } =
try!(doc_at(self.parent.data, self.pos));
- debug!("self.parent={}-{} self.pos={} r_tag={} r_doc={}-{}",
+ debug!("self.parent={:?}-{:?} self.pos={:?} r_tag={:?} r_doc={:?}-{:?}",
self.parent.start,
self.parent.end,
self.pos,
r_doc.start,
r_doc.end);
if r_tag != (exp_tag as uint) {
- return Err(Expected(format!("expected EBML doc with tag {} but \
- found tag {}", exp_tag, r_tag)));
+ return Err(Expected(format!("expected EBML doc with tag {:?} but \
+ found tag {:?}", exp_tag, r_tag)));
}
if r_doc.end > self.parent.end {
return Err(Expected(format!("invalid EBML, child extends to \
fn _next_uint(&mut self, exp_tag: EbmlEncoderTag) -> DecodeResult<uint> {
let r = doc_as_u32(try!(self.next_doc(exp_tag)));
- debug!("_next_uint exp_tag={} result={}", exp_tag, r);
+ debug!("_next_uint exp_tag={:?} result={:?}", exp_tag, r);
Ok(r as uint)
}
}
}
- #[cfg(stage0)]
- impl<'doc> serialize::Decoder<Error> for Decoder<'doc> {
- fn read_nil(&mut self) -> DecodeResult<()> { Ok(()) }
-
- fn read_u64(&mut self) -> DecodeResult<u64> { Ok(doc_as_u64(try!(self.next_doc(EsU64)))) }
- fn read_u32(&mut self) -> DecodeResult<u32> { Ok(doc_as_u32(try!(self.next_doc(EsU32)))) }
- fn read_u16(&mut self) -> DecodeResult<u16> { Ok(doc_as_u16(try!(self.next_doc(EsU16)))) }
- fn read_u8 (&mut self) -> DecodeResult<u8 > { Ok(doc_as_u8 (try!(self.next_doc(EsU8 )))) }
- fn read_uint(&mut self) -> DecodeResult<uint> {
- let v = doc_as_u64(try!(self.next_doc(EsUint)));
- if v > (::std::uint::MAX as u64) {
- Err(IntTooBig(v as uint))
- } else {
- Ok(v as uint)
- }
- }
-
- fn read_i64(&mut self) -> DecodeResult<i64> {
- Ok(doc_as_u64(try!(self.next_doc(EsI64))) as i64)
- }
- fn read_i32(&mut self) -> DecodeResult<i32> {
- Ok(doc_as_u32(try!(self.next_doc(EsI32))) as i32)
- }
- fn read_i16(&mut self) -> DecodeResult<i16> {
- Ok(doc_as_u16(try!(self.next_doc(EsI16))) as i16)
- }
- fn read_i8 (&mut self) -> DecodeResult<i8> {
- Ok(doc_as_u8(try!(self.next_doc(EsI8 ))) as i8)
- }
- fn read_int(&mut self) -> DecodeResult<int> {
- let v = doc_as_u64(try!(self.next_doc(EsInt))) as i64;
- if v > (int::MAX as i64) || v < (int::MIN as i64) {
- debug!("FIXME \\#6122: Removing this makes this function miscompile");
- Err(IntTooBig(v as uint))
- } else {
- Ok(v as int)
- }
- }
-
- fn read_bool(&mut self) -> DecodeResult<bool> {
- Ok(doc_as_u8(try!(self.next_doc(EsBool))) != 0)
- }
-
- fn read_f64(&mut self) -> DecodeResult<f64> {
- let bits = doc_as_u64(try!(self.next_doc(EsF64)));
- Ok(unsafe { transmute(bits) })
- }
- fn read_f32(&mut self) -> DecodeResult<f32> {
- let bits = doc_as_u32(try!(self.next_doc(EsF32)));
- Ok(unsafe { transmute(bits) })
- }
- fn read_char(&mut self) -> DecodeResult<char> {
- Ok(char::from_u32(doc_as_u32(try!(self.next_doc(EsChar)))).unwrap())
- }
- fn read_str(&mut self) -> DecodeResult<String> {
- Ok(try!(self.next_doc(EsStr)).as_str())
- }
-
- // Compound types:
- fn read_enum<T, F>(&mut self, name: &str, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_enum({})", name);
- try!(self._check_label(name));
-
- let doc = try!(self.next_doc(EsEnum));
-
- let (old_parent, old_pos) = (self.parent, self.pos);
- self.parent = doc;
- self.pos = self.parent.start;
-
- let result = try!(f(self));
-
- self.parent = old_parent;
- self.pos = old_pos;
- Ok(result)
- }
-
- fn read_enum_variant<T, F>(&mut self, _: &[&str],
- mut f: F) -> DecodeResult<T>
- where F: FnMut(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
- {
- debug!("read_enum_variant()");
- let idx = try!(self._next_uint(EsEnumVid));
- debug!(" idx={}", idx);
-
- let doc = try!(self.next_doc(EsEnumBody));
-
- let (old_parent, old_pos) = (self.parent, self.pos);
- self.parent = doc;
- self.pos = self.parent.start;
-
- let result = try!(f(self, idx));
-
- self.parent = old_parent;
- self.pos = old_pos;
- Ok(result)
- }
-
- fn read_enum_variant_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_enum_variant_arg(idx={})", idx);
- f(self)
- }
-
- fn read_enum_struct_variant<T, F>(&mut self, _: &[&str],
- mut f: F) -> DecodeResult<T>
- where F: FnMut(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
- {
- debug!("read_enum_struct_variant()");
- let idx = try!(self._next_uint(EsEnumVid));
- debug!(" idx={}", idx);
-
- let doc = try!(self.next_doc(EsEnumBody));
-
- let (old_parent, old_pos) = (self.parent, self.pos);
- self.parent = doc;
- self.pos = self.parent.start;
-
- let result = try!(f(self, idx));
-
- self.parent = old_parent;
- self.pos = old_pos;
- Ok(result)
- }
-
- fn read_enum_struct_variant_field<T, F>(&mut self,
- name: &str,
- idx: uint,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_enum_struct_variant_arg(name={}, idx={})", name, idx);
- f(self)
- }
-
- fn read_struct<T, F>(&mut self, name: &str, _: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_struct(name={})", name);
- f(self)
- }
-
- fn read_struct_field<T, F>(&mut self, name: &str, idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_struct_field(name={}, idx={})", name, idx);
- try!(self._check_label(name));
- f(self)
- }
-
- fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_tuple()");
- self.read_seq(move |d, len| {
- if len == tuple_len {
- f(d)
- } else {
- Err(Expected(format!("Expected tuple of length `{}`, \
- found tuple of length `{}`", tuple_len, len)))
- }
- })
- }
-
- fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_tuple_arg(idx={})", idx);
- self.read_seq_elt(idx, f)
- }
-
- fn read_tuple_struct<T, F>(&mut self, name: &str, len: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_tuple_struct(name={})", name);
- self.read_tuple(len, f)
- }
-
- fn read_tuple_struct_arg<T, F>(&mut self,
- idx: uint,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_tuple_struct_arg(idx={})", idx);
- self.read_tuple_arg(idx, f)
- }
-
- fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
- F: FnMut(&mut Decoder<'doc>, bool) -> DecodeResult<T>,
- {
- debug!("read_option()");
- self.read_enum("Option", move |this| {
- this.read_enum_variant(&["None", "Some"], move |this, idx| {
- match idx {
- 0 => f(this, false),
- 1 => f(this, true),
- _ => {
- Err(Expected(format!("Expected None or Some")))
- }
- }
- })
- })
- }
-
- fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
- {
- debug!("read_seq()");
- self.push_doc(EsVec, move |d| {
- let len = try!(d._next_uint(EsVecLen));
- debug!(" len={}", len);
- f(d, len)
- })
- }
-
- fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_seq_elt(idx={})", idx);
- self.push_doc(EsVecElt, f)
- }
-
- fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
- {
- debug!("read_map()");
- self.push_doc(EsMap, move |d| {
- let len = try!(d._next_uint(EsMapLen));
- debug!(" len={}", len);
- f(d, len)
- })
- }
-
- fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_map_elt_key(idx={})", idx);
- self.push_doc(EsMapKey, f)
- }
-
- fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
- {
- debug!("read_map_elt_val(idx={})", idx);
- self.push_doc(EsMapVal, f)
- }
-
- fn error(&mut self, err: &str) -> Error {
- ApplicationError(err.to_string())
- }
- }
-
- #[cfg(not(stage0))]
impl<'doc> serialize::Decoder for Decoder<'doc> {
type Error = Error;
fn read_nil(&mut self) -> DecodeResult<()> { Ok(()) }
}
pub fn start_tag(&mut self, tag_id: uint) -> EncodeResult {
- debug!("Start tag {}", tag_id);
+ debug!("Start tag {:?}", tag_id);
// Write the enum ID:
try!(write_vuint(self.writer, tag_id));
try!(write_sized_vuint(self.writer, size, 4u));
let r = try!(self.writer.seek(cur_pos as i64, io::SeekSet));
- debug!("End tag (size = {})", size);
+ debug!("End tag (size = {:?})", size);
Ok(r)
}
}
pub fn wr_bytes(&mut self, b: &[u8]) -> EncodeResult {
- debug!("Write {} bytes", b.len());
+ debug!("Write {:?} bytes", b.len());
self.writer.write(b)
}
pub fn wr_str(&mut self, s: &str) -> EncodeResult {
- debug!("Write str: {}", s);
+ debug!("Write str: {:?}", s);
self.writer.write(s.as_bytes())
}
}
}
}
- #[cfg(stage0)]
- impl<'a, W: Writer + Seek> serialize::Encoder<io::IoError> for Encoder<'a, W> {
-
- fn emit_nil(&mut self) -> EncodeResult {
- Ok(())
- }
-
- fn emit_uint(&mut self, v: uint) -> EncodeResult {
- self.wr_tagged_u64(EsUint as uint, v as u64)
- }
- fn emit_u64(&mut self, v: u64) -> EncodeResult {
- self.wr_tagged_u64(EsU64 as uint, v)
- }
- fn emit_u32(&mut self, v: u32) -> EncodeResult {
- self.wr_tagged_u32(EsU32 as uint, v)
- }
- fn emit_u16(&mut self, v: u16) -> EncodeResult {
- self.wr_tagged_u16(EsU16 as uint, v)
- }
- fn emit_u8(&mut self, v: u8) -> EncodeResult {
- self.wr_tagged_u8(EsU8 as uint, v)
- }
-
- fn emit_int(&mut self, v: int) -> EncodeResult {
- self.wr_tagged_i64(EsInt as uint, v as i64)
- }
- fn emit_i64(&mut self, v: i64) -> EncodeResult {
- self.wr_tagged_i64(EsI64 as uint, v)
- }
- fn emit_i32(&mut self, v: i32) -> EncodeResult {
- self.wr_tagged_i32(EsI32 as uint, v)
- }
- fn emit_i16(&mut self, v: i16) -> EncodeResult {
- self.wr_tagged_i16(EsI16 as uint, v)
- }
- fn emit_i8(&mut self, v: i8) -> EncodeResult {
- self.wr_tagged_i8(EsI8 as uint, v)
- }
-
- fn emit_bool(&mut self, v: bool) -> EncodeResult {
- self.wr_tagged_u8(EsBool as uint, v as u8)
- }
-
- fn emit_f64(&mut self, v: f64) -> EncodeResult {
- let bits = unsafe { mem::transmute(v) };
- self.wr_tagged_u64(EsF64 as uint, bits)
- }
- fn emit_f32(&mut self, v: f32) -> EncodeResult {
- let bits = unsafe { mem::transmute(v) };
- self.wr_tagged_u32(EsF32 as uint, bits)
- }
- fn emit_char(&mut self, v: char) -> EncodeResult {
- self.wr_tagged_u32(EsChar as uint, v as u32)
- }
-
- fn emit_str(&mut self, v: &str) -> EncodeResult {
- self.wr_tagged_str(EsStr as uint, v)
- }
-
- fn emit_enum<F>(&mut self, name: &str, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- try!(self._emit_label(name));
- try!(self.start_tag(EsEnum as uint));
- try!(f(self));
- self.end_tag()
- }
-
- fn emit_enum_variant<F>(&mut self,
- _: &str,
- v_id: uint,
- _: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- try!(self._emit_tagged_uint(EsEnumVid, v_id));
- try!(self.start_tag(EsEnumBody as uint));
- try!(f(self));
- self.end_tag()
- }
-
- fn emit_enum_variant_arg<F>(&mut self, _: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- f(self)
- }
-
- fn emit_enum_struct_variant<F>(&mut self,
- v_name: &str,
- v_id: uint,
- cnt: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- self.emit_enum_variant(v_name, v_id, cnt, f)
- }
-
- fn emit_enum_struct_variant_field<F>(&mut self,
- _: &str,
- idx: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- self.emit_enum_variant_arg(idx, f)
- }
-
- fn emit_struct<F>(&mut self, _: &str, _len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- f(self)
- }
-
- fn emit_struct_field<F>(&mut self, name: &str, _: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- try!(self._emit_label(name));
- f(self)
- }
-
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- self.emit_seq(len, f)
- }
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- self.emit_seq(len, f)
- }
- fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_option<F>(&mut self, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- self.emit_enum("Option", f)
- }
- fn emit_option_none(&mut self) -> EncodeResult {
- self.emit_enum_variant("None", 0, 0, |_| Ok(()))
- }
- fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
-
- self.emit_enum_variant("Some", 1, 1, f)
- }
-
- fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
-
- try!(self.start_tag(EsVec as uint));
- try!(self._emit_tagged_uint(EsVecLen, len));
- try!(f(self));
- self.end_tag()
- }
-
- fn emit_seq_elt<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
-
- try!(self.start_tag(EsVecElt as uint));
- try!(f(self));
- self.end_tag()
- }
-
- fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
-
- try!(self.start_tag(EsMap as uint));
- try!(self._emit_tagged_uint(EsMapLen, len));
- try!(f(self));
- self.end_tag()
- }
-
- fn emit_map_elt_key<F>(&mut self, _idx: uint, mut f: F) -> EncodeResult where
- F: FnMut(&mut Encoder<'a, W>) -> EncodeResult,
- {
-
- try!(self.start_tag(EsMapKey as uint));
- try!(f(self));
- self.end_tag()
- }
-
- fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a, W>) -> EncodeResult,
- {
- try!(self.start_tag(EsMapVal as uint));
- try!(f(self));
- self.end_tag()
- }
- }
- #[cfg(not(stage0))]
impl<'a, W: Writer + Seek> serialize::Encoder for Encoder<'a, W> {
type Error = io::IoError;
#[test]
fn test_option_int() {
fn test_v(v: Option<int>) {
- debug!("v == {}", v);
+ debug!("v == {:?}", v);
let mut wr = SeekableMemWriter::new();
{
let mut rbml_w = writer::Encoder::new(&mut wr);
let rbml_doc = Doc::new(wr.get_ref());
let mut deser = reader::Decoder::new(rbml_doc);
let v1 = Decodable::decode(&mut deser).unwrap();
- debug!("v1 == {}", v1);
+ debug!("v1 == {:?}", v1);
assert_eq!(v, v1);
}
// This is a bit hacky since we have to skip over the initial
// 'Save' instruction.
let mut pre = String::with_capacity(5);
- for inst in c.insts[1..].iter() {
+ for inst in c.insts.index(&(1..)).iter() {
match *inst {
OneChar(c, FLAG_EMPTY) => pre.push(c),
_ => break
//! Regular expressions implemented in Rust
//!
//! For official documentation, see the rust-lang/regex crate
-
#![crate_name = "regex"]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
-#![feature(macro_rules, slicing_syntax, globs)]
-#![feature(unboxed_closures)]
-#![feature(associated_types)]
+#![feature(slicing_syntax)]
#![deny(missing_docs)]
#[cfg(test)]
use std::fmt;
use std::iter;
use std::num;
+use std::ops::Index;
/// Static data containing Unicode ranges for general categories and scripts.
use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
impl fmt::Show for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "Regex syntax error near position {}: {}",
+ write!(f, "Regex syntax error near position {}: {:?}",
self.pos, self.msg)
}
}
fn flags(&self) -> Flags {
match *self {
Paren(flags, _, _) => flags,
- _ => panic!("Cannot get flags from {}", self),
+ _ => panic!("Cannot get flags from {:?}", self),
}
}
match *self {
Paren(_, 0, _) => None,
Paren(_, c, _) => Some(c),
- _ => panic!("Cannot get capture group from {}", self),
+ _ => panic!("Cannot get capture group from {:?}", self),
}
}
Some(name.clone())
}
}
- _ => panic!("Cannot get capture name from {}", self),
+ _ => panic!("Cannot get capture name from {:?}", self),
}
}
fn unwrap(self) -> Result<Ast, Error> {
match self {
Expr(x) => Ok(x),
- _ => panic!("Tried to unwrap non-AST item: {}", self),
+ _ => panic!("Tried to unwrap non-AST item: {:?}", self),
}
}
}
match self.next_char() {
true => Ok(()),
false => {
- self.err(format!("Expected {} but got EOF.",
- expected)[])
+ self.err(format!("Expected {:?} but got EOF.",
+ expected).index(&FullRange))
}
}
}
fn expect(&mut self, expected: char) -> Result<(), Error> {
match self.next_char() {
true if self.cur() == expected => Ok(()),
- true => self.err(format!("Expected '{}' but got '{}'.",
- expected, self.cur())[]),
+ true => self.err(format!("Expected '{:?}' but got '{:?}'.",
+ expected, self.cur()).index(&FullRange)),
false => {
- self.err(format!("Expected '{}' but got EOF.",
- expected)[])
+ self.err(format!("Expected '{:?}' but got EOF.",
+ expected).index(&FullRange))
}
}
}
continue
}
Some(ast) =>
- panic!("Expected Class AST but got '{}'", ast),
+ panic!("Expected Class AST but got '{:?}'", ast),
// Just drop down and try to add as a regular character.
None => {},
},
return self.err(
"\\A, \\z, \\b and \\B are not valid escape \
sequences inside a character class."),
- ast => panic!("Unexpected AST item '{}'", ast),
+ ast => panic!("Unexpected AST item '{:?}'", ast),
}
}
']' if ranges.len() > 0 || alts.len() > 0 => {
match try!(self.parse_escape()) {
Literal(c3, _) => c2 = c3, // allow literal escapes below
ast =>
- return self.err(format!("Expected a literal, but got {}.",
- ast)[]),
+ return self.err(format!("Expected a literal, but got {:?}.",
+ ast).index(&FullRange)),
}
}
if c2 < c {
return self.err(format!("Invalid character class \
range '{}-{}'",
c,
- c2)[])
+ c2).index(&FullRange))
}
ranges.push((c, self.cur()))
} else {
FLAG_EMPTY
};
let name = self.slice(name_start, closer - 1);
- match find_class(ASCII_CLASSES, name[]) {
+ match find_class(ASCII_CLASSES, name.index(&FullRange)) {
None => None,
Some(ranges) => {
self.chari = closer;
None => {
return self.err(format!("No closing brace for counted \
repetition starting at position \
- {}.",
- start)[])
+ {:?}.",
+ start).index(&FullRange))
}
};
self.chari = closer;
let greed = try!(self.get_next_greedy());
- let inner = self.chars[start+1..closer].iter().cloned()
+ let inner = self.chars.index(&((start+1)..closer)).iter().cloned()
.collect::<String>();
// Parse the min and max values from the regex.
let (mut min, mut max): (uint, Option<uint>);
if !inner.contains(",") {
- min = try!(self.parse_uint(inner[]));
+ min = try!(self.parse_uint(inner.index(&FullRange)));
max = Some(min);
} else {
let pieces: Vec<&str> = inner.splitn(1, ',').collect();
if min > MAX_REPEAT {
return self.err(format!(
"{} exceeds maximum allowed repetitions ({})",
- min, MAX_REPEAT)[]);
+ min, MAX_REPEAT).index(&FullRange));
}
if max.is_some() {
let m = max.unwrap();
if m > MAX_REPEAT {
return self.err(format!(
"{} exceeds maximum allowed repetitions ({})",
- m, MAX_REPEAT)[]);
+ m, MAX_REPEAT).index(&FullRange));
}
if m < min {
return self.err(format!(
"Max repetitions ({}) cannot be smaller than min \
- repetitions ({}).", m, min)[]);
+ repetitions ({}).", m, min).index(&FullRange));
}
}
Ok(AstClass(ranges, flags))
}
_ => {
- self.err(format!("Invalid escape sequence '\\\\{}'", c)[])
+ self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange))
}
}
}
Some(i) => i,
None => return self.err(format!(
"Missing '}}' for unclosed '{{' at position {}",
- self.chari)[]),
+ self.chari).index(&FullRange)),
};
if closer - self.chari + 1 == 0 {
return self.err("No Unicode class name found.")
name = self.slice(self.chari + 1, self.chari + 2);
self.chari += 1;
}
- match find_class(UNICODE_CLASSES, name[]) {
+ match find_class(UNICODE_CLASSES, name.index(&FullRange)) {
None => {
return self.err(format!("Could not find Unicode class '{}'",
- name)[])
+ name).index(&FullRange))
}
Some(ranges) => {
Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE)))
}
}
let s = self.slice(start, end);
- match num::from_str_radix::<u32>(s[], 8) {
+ match num::from_str_radix::<u32>(s.index(&FullRange), 8) {
Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
None => {
- self.err(format!("Could not parse '{}' as octal number.",
- s)[])
+ self.err(format!("Could not parse '{:?}' as octal number.",
+ s).index(&FullRange))
}
}
}
None => {
return self.err(format!("Missing '}}' for unclosed \
'{{' at position {}",
- start)[])
+ start).index(&FullRange))
}
Some(i) => i,
};
self.chari = closer;
- self.parse_hex_digits(self.slice(start, closer)[])
+ self.parse_hex_digits(self.slice(start, closer).index(&FullRange))
}
// Parses a two-digit hex number.
match num::from_str_radix::<u32>(s, 16) {
Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
None => {
- self.err(format!("Could not parse '{}' as hex number.", s)[])
+ self.err(format!("Could not parse '{}' as hex number.", s).index(&FullRange))
}
}
}
}
if self.names.contains(&name) {
return self.err(format!("Duplicate capture group name '{}'.",
- name)[])
+ name).index(&FullRange))
}
self.names.push(name.clone());
self.chari = closer;
if sign < 0 {
return self.err(format!(
"Cannot negate flags twice in '{}'.",
- self.slice(start, self.chari + 1))[])
+ self.slice(start, self.chari + 1)).index(&FullRange))
}
sign = -1;
saw_flag = false;
if !saw_flag {
return self.err(format!(
"A valid flag does not follow negation in '{}'",
- self.slice(start, self.chari + 1))[])
+ self.slice(start, self.chari + 1)).index(&FullRange))
}
flags = flags ^ flags;
}
return Ok(())
}
_ => return self.err(format!(
- "Unrecognized flag '{}'.", self.cur())[]),
+ "Unrecognized flag '{}'.", self.cur()).index(&FullRange)),
}
}
}
Some(i) => Ok(i),
None => {
self.err(format!("Expected an unsigned integer but got '{}'.",
- s)[])
+ s).index(&FullRange))
}
}
}
Some(c) => Ok(c),
None => {
self.err(format!("Could not decode '{}' to unicode \
- character.", n)[])
+ character.", n).index(&FullRange))
}
}
}
}
fn slice(&self, start: uint, end: uint) -> String {
- self.chars[start..end].iter().cloned().collect()
+ self.chars.index(&(start..end)).iter().cloned().collect()
}
}
}
}
+#[cfg(stage0)]
+//FIXME: remove after stage0 snapshot
impl fmt::Show for Regex {
/// Shows the original regular expression.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", self.as_str())
+ fmt::String::fmt(self.as_str(), f)
+ }
+}
+
+impl fmt::String for Regex {
+ /// Shows the original regular expression.
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self.as_str(), f)
}
}
}
let (s, e) = cap.pos(0).unwrap(); // captures only reports matches
- new.push_str(text[last_match..s]);
- new.push_str(rep.reg_replace(&cap)[]);
+ new.push_str(text.index(&(last_match..s)));
+ new.push_str(rep.reg_replace(&cap).index(&FullRange));
last_match = e;
}
- new.push_str(text[last_match..text.len()]);
+ new.push_str(text.index(&(last_match..text.len())));
return new;
}
/// Returns the original string of this regex.
pub fn as_str<'a>(&'a self) -> &'a str {
match *self {
- Dynamic(ExDynamic { ref original, .. }) => original[],
- Native(ExNative { ref original, .. }) => original[],
+ Dynamic(ExDynamic { ref original, .. }) => original.index(&FullRange),
+ Native(ExNative { ref original, .. }) => original.index(&FullRange),
}
}
if self.last >= text.len() {
None
} else {
- let s = text[self.last..text.len()];
+ let s = text.index(&(self.last..text.len()));
self.last = text.len();
Some(s)
}
}
Some((s, e)) => {
- let matched = text[self.last..s];
+ let matched = text.index(&(self.last..s));
self.last = e;
Some(matched)
}
} else {
self.cur += 1;
if self.cur >= self.limit {
- Some(text[self.splits.last..text.len()])
+ Some(text.index(&(self.splits.last..text.len())))
} else {
self.splits.next()
}
})
});
let re = Regex::new(r"\$\$").unwrap();
- re.replace_all(text[], NoExpand("$"))
+ re.replace_all(text.index(&FullRange), NoExpand("$"))
}
/// Returns the number of captured groups.
($re:expr) => (
match ::regex::Regex::new($re) {
Ok(re) => re,
- Err(err) => panic!("{}", err),
+ Err(err) => panic!("{:?}", err),
}
);
}
// actual capture groups to match test set.
let mut sgot = got.as_slice();
if sgot.len() > expected.len() {
- sgot = sgot[0..expected.len()]
+ sgot = &sgot[..expected.len()]
}
if expected != sgot {
- panic!("For RE '{}' against '{}', expected '{}' but got '{}'",
+ panic!("For RE '{}' against '{}', expected '{:?}' but got '{:?}'",
$re, text, expected, sgot);
}
}
// out early.
if self.prog.prefix.len() > 0 && clist.size == 0 {
let needle = self.prog.prefix.as_bytes();
- let haystack = self.input.as_bytes()[self.ic..];
+ let haystack = self.input.as_bytes().index(&(self.ic..));
match find_prefix(needle, haystack) {
None => break,
Some(i) => {
#[inline]
fn groups<'r>(&'r mut self, i: uint) -> &'r mut [Option<uint>] {
- self.queue[i].groups.as_mut_slice()
+ let q = &mut self.queue[i];
+ q.groups.as_mut_slice()
}
}
html_root_url = "http://doc.rust-lang.org/nightly/")]
#![allow(unknown_features)]
-#![feature(default_type_params, globs, macro_rules, phase, quote)]
+#![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
-#![feature(associated_types)]
+#![feature(old_impl_check)]
extern crate arena;
extern crate flate;
extern crate serialize;
extern crate rbml;
extern crate collections;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate syntax;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate syntax;
+#[macro_use] extern crate log;
+#[macro_use] extern crate syntax;
extern crate "serialize" as rustc_serialize; // used by deriving
use syntax::attr::{self, AttrMetaMethods};
use syntax::codemap::{Span, DUMMY_SP};
use syntax::parse::token;
-use syntax::ast::{TyI, TyU, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
+use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64};
use syntax::ast_util;
use syntax::ptr::P;
use syntax::visit::{self, Visitor};
match lit.node {
ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) |
ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => {
- let int_type = if t == ast::TyI {
+ let int_type = if t == ast::TyIs {
cx.sess().target.int_type
} else { t };
let (min, max) = int_ty_range(int_type);
};
},
ty::ty_uint(t) => {
- let uint_type = if t == ast::TyU {
+ let uint_type = if t == ast::TyUs {
cx.sess().target.uint_type
} else { t };
let (min, max) = uint_ty_range(uint_type);
// warnings are consistent between 32- and 64-bit platforms
fn int_ty_range(int_ty: ast::IntTy) -> (i64, i64) {
match int_ty {
- ast::TyI => (i64::MIN, i64::MAX),
+ ast::TyIs=> (i64::MIN, i64::MAX),
ast::TyI8 => (i8::MIN as i64, i8::MAX as i64),
ast::TyI16 => (i16::MIN as i64, i16::MAX as i64),
ast::TyI32 => (i32::MIN as i64, i32::MAX as i64),
fn uint_ty_range(uint_ty: ast::UintTy) -> (u64, u64) {
match uint_ty {
- ast::TyU => (u64::MIN, u64::MAX),
+ ast::TyUs=> (u64::MIN, u64::MAX),
ast::TyU8 => (u8::MIN as u64, u8::MAX as u64),
ast::TyU16 => (u16::MIN as u64, u16::MAX as u64),
ast::TyU32 => (u32::MIN as u64, u32::MAX as u64),
fn int_ty_bits(int_ty: ast::IntTy, target_int_ty: ast::IntTy) -> u64 {
match int_ty {
- ast::TyI => int_ty_bits(target_int_ty, target_int_ty),
+ ast::TyIs=> int_ty_bits(target_int_ty, target_int_ty),
ast::TyI8 => i8::BITS as u64,
ast::TyI16 => i16::BITS as u64,
ast::TyI32 => i32::BITS as u64,
fn uint_ty_bits(uint_ty: ast::UintTy, target_uint_ty: ast::UintTy) -> u64 {
match uint_ty {
- ast::TyU => uint_ty_bits(target_uint_ty, target_uint_ty),
+ ast::TyUs=> uint_ty_bits(target_uint_ty, target_uint_ty),
ast::TyU8 => u8::BITS as u64,
ast::TyU16 => u16::BITS as u64,
ast::TyU32 => u32::BITS as u64,
impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
fn check_def(&mut self, sp: Span, ty_id: ast::NodeId, path_id: ast::NodeId) {
match self.cx.tcx.def_map.borrow()[path_id].clone() {
- def::DefPrimTy(ast::TyInt(ast::TyI)) => {
+ def::DefPrimTy(ast::TyInt(ast::TyIs)) => {
self.cx.span_lint(IMPROPER_CTYPES, sp,
- "found rust type `int` in foreign module, while \
+ "found rust type `isize` in foreign module, while \
libc::c_int or libc::c_long should be used");
}
- def::DefPrimTy(ast::TyUint(ast::TyU)) => {
+ def::DefPrimTy(ast::TyUint(ast::TyUs)) => {
self.cx.span_lint(IMPROPER_CTYPES, sp,
- "found rust type `uint` in foreign module, while \
+ "found rust type `usize` in foreign module, while \
libc::c_uint or libc::c_ulong should be used");
}
def::DefTy(..) => {
if n_uniq > 0 {
let s = ty_to_string(cx.tcx, ty);
let m = format!("type uses owned (Box type) pointers: {}", s);
- cx.span_lint(BOX_POINTERS, span, m[]);
+ cx.span_lint(BOX_POINTERS, span, m.index(&FullRange));
}
}
}
}
fn check_item(&mut self, cx: &Context, item: &ast::Item) {
- if !attr::contains_name(item.attrs[], "automatically_derived") {
+ if !attr::contains_name(item.attrs.index(&FullRange), "automatically_derived") {
return
}
let did = match item.node {
// FIXME: #19470 this shouldn't be needed forever
"old_orphan_check",
+ "old_impl_check",
];
static CRATE_ATTRS: &'static [&'static str] = &[
ty::ty_enum(did, _) => {
if ast_util::is_local(did) {
if let ast_map::NodeItem(it) = cx.tcx.map.get(did.node) {
- warned |= check_must_use(cx, it.attrs[], s.span);
+ warned |= check_must_use(cx, it.attrs.index(&FullRange), s.span);
}
} else {
csearch::get_item_attrs(&cx.sess().cstore, did, |attrs| {
- warned |= check_must_use(cx, attrs[], s.span);
+ warned |= check_must_use(cx, attrs.index(&FullRange), s.span);
});
}
}
msg.push_str(s.get());
}
}
- cx.span_lint(UNUSED_MUST_USE, sp, msg[]);
+ cx.span_lint(UNUSED_MUST_USE, sp, msg.index(&FullRange));
return true;
}
}
} else {
format!("{} `{}` should have a camel case name such as `{}`", sort, s, c)
};
- cx.span_lint(NON_CAMEL_CASE_TYPES, span, m[]);
+ cx.span_lint(NON_CAMEL_CASE_TYPES, span, m.index(&FullRange));
}
}
}
if !is_snake_case(ident) {
cx.span_lint(NON_SNAKE_CASE, span,
format!("{} `{}` should have a snake case name such as `{}`",
- sort, s, to_snake_case(s.get()))[]);
+ sort, s, to_snake_case(s.get())).index(&FullRange));
}
}
}
format!("static constant `{}` should have an uppercase name \
such as `{}`",
s.get(), s.get().chars().map(|c| c.to_uppercase())
- .collect::<String>()[])[]);
+ .collect::<String>().index(&FullRange)).index(&FullRange));
}
}
_ => {}
format!("static constant in pattern `{}` should have an uppercase \
name such as `{}`",
s.get(), s.get().chars().map(|c| c.to_uppercase())
- .collect::<String>()[])[]);
+ .collect::<String>().index(&FullRange)).index(&FullRange));
}
}
_ => {}
if !necessary {
cx.span_lint(UNUSED_PARENS, value.span,
format!("unnecessary parentheses around {}",
- msg)[])
+ msg).index(&FullRange))
}
}
let m = format!("braces around {} is unnecessary",
token::get_ident(*name).get());
cx.span_lint(UNUSED_IMPORT_BRACES, view_item.span,
- m[]);
+ m.index(&FullRange));
},
_ => ()
}
if ident.node.as_str() == fieldpat.node.ident.as_str() {
cx.span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span,
format!("the `{}:` in this pattern is redundant and can \
- be removed", ident.node.as_str())[])
+ be removed", ident.node.as_str()).index(&FullRange))
}
}
}
let ident = path1.node;
if let ast::BindByValue(ast::MutMutable) = mode {
if !token::get_ident(ident).get().starts_with("_") {
- match mutables.entry(&ident.name.uint()) {
+ match mutables.entry(ident.name.uint()) {
Vacant(entry) => { entry.insert(vec![id]); },
Occupied(mut entry) => { entry.get_mut().push(id); },
}
fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
if let ast::ExprMatch(_, ref arms, _) = e.node {
for a in arms.iter() {
- self.check_unused_mut_pat(cx, a.pats[])
+ self.check_unused_mut_pat(cx, a.pats.index(&FullRange))
}
}
}
});
if !has_doc {
cx.span_lint(MISSING_DOCS, sp,
- format!("missing documentation for {}", desc)[]);
+ format!("missing documentation for {}", desc).index(&FullRange));
}
}
}
let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| {
attr.check_name("doc") && match attr.meta_item_list() {
None => false,
- Some(l) => attr::contains_name(l[], "hidden"),
+ Some(l) => attr::contains_name(l.index(&FullRange), "hidden"),
}
});
self.doc_hidden_stack.push(doc_hidden);
}
fn check_crate(&mut self, cx: &Context, krate: &ast::Crate) {
- self.check_missing_docs_attrs(cx, None, krate.attrs[],
+ self.check_missing_docs_attrs(cx, None, krate.attrs.index(&FullRange),
krate.span, "crate");
}
ast::ItemTy(..) => "a type alias",
_ => return
};
- self.check_missing_docs_attrs(cx, Some(it.id), it.attrs[],
+ self.check_missing_docs_attrs(cx, Some(it.id), it.attrs.index(&FullRange),
it.span, desc);
}
// Otherwise, doc according to privacy. This will also check
// doc for default methods defined on traits.
- self.check_missing_docs_attrs(cx, Some(m.id), m.attrs[],
+ self.check_missing_docs_attrs(cx, Some(m.id), m.attrs.index(&FullRange),
m.span, "a method");
}
}
fn check_ty_method(&mut self, cx: &Context, tm: &ast::TypeMethod) {
- self.check_missing_docs_attrs(cx, Some(tm.id), tm.attrs[],
+ self.check_missing_docs_attrs(cx, Some(tm.id), tm.attrs.index(&FullRange),
tm.span, "a type method");
}
let cur_struct_def = *self.struct_def_stack.last()
.expect("empty struct_def_stack");
self.check_missing_docs_attrs(cx, Some(cur_struct_def),
- sf.node.attrs[], sf.span,
+ sf.node.attrs.index(&FullRange), sf.span,
"a struct field")
}
}
}
fn check_variant(&mut self, cx: &Context, v: &ast::Variant, _: &ast::Generics) {
- self.check_missing_docs_attrs(cx, Some(v.node.id), v.node.attrs[],
+ self.check_missing_docs_attrs(cx, Some(v.node.id), v.node.attrs.index(&FullRange),
v.span, "a variant");
assert!(!self.in_variant);
self.in_variant = true;
Warn,
"detects use of #[deprecated] items"
}
-
// FIXME #6875: Change to Warn after std library stabilization is complete
declare_lint! {
EXPERIMENTAL,
_ => format!("use of {} item", label)
};
- cx.span_lint(lint, span, msg[]);
+ cx.span_lint(lint, span, msg.index(&FullRange));
}
fn is_internal(&self, cx: &Context, span: Span) -> bool {
"detects transmutes of fat pointers"
}
-declare_lint!{
+declare_lint! {
pub MISSING_COPY_IMPLEMENTATIONS,
Warn,
"detects potentially-forgotten implementations of `Copy`"
}
pub fn get_lints<'t>(&'t self) -> &'t [(&'static Lint, bool)] {
- self.lints[]
+ self.lints.index(&FullRange)
}
pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec<LintId>, bool)> {
match (sess, from_plugin) {
// We load builtin lints first, so a duplicate is a compiler bug.
// Use early_error when handling -W help with no crate.
- (None, _) => early_error(msg[]),
- (Some(sess), false) => sess.bug(msg[]),
+ (None, _) => early_error(msg.index(&FullRange)),
+ (Some(sess), false) => sess.bug(msg.index(&FullRange)),
// A duplicate name from a plugin is a user error.
- (Some(sess), true) => sess.err(msg[]),
+ (Some(sess), true) => sess.err(msg.index(&FullRange)),
}
}
match (sess, from_plugin) {
// We load builtin lints first, so a duplicate is a compiler bug.
// Use early_error when handling -W help with no crate.
- (None, _) => early_error(msg[]),
- (Some(sess), false) => sess.bug(msg[]),
+ (None, _) => early_error(msg.index(&FullRange)),
+ (Some(sess), false) => sess.bug(msg.index(&FullRange)),
// A duplicate name from a plugin is a user error.
- (Some(sess), true) => sess.err(msg[]),
+ (Some(sess), true) => sess.err(msg.index(&FullRange)),
}
}
}
let warning = format!("lint {} has been renamed to {}",
lint_name, new_name);
match span {
- Some(span) => sess.span_warn(span, warning[]),
- None => sess.warn(warning[]),
+ Some(span) => sess.span_warn(span, warning.index(&FullRange)),
+ None => sess.warn(warning.index(&FullRange)),
};
Some(lint_id)
}
pub fn process_command_line(&mut self, sess: &Session) {
for &(ref lint_name, level) in sess.opts.lint_opts.iter() {
- match self.find_lint(lint_name[], sess, None) {
+ match self.find_lint(lint_name.index(&FullRange), sess, None) {
Some(lint_id) => self.set_level(lint_id, (level, CommandLine)),
None => {
match self.lint_groups.iter().map(|(&x, pair)| (x, pair.0.clone()))
.collect::<FnvHashMap<&'static str,
Vec<LintId>>>()
- .get(lint_name[]) {
+ .get(lint_name.index(&FullRange)) {
Some(v) => {
v.iter()
.map(|lint_id: &LintId|
.collect::<Vec<()>>();
}
None => sess.err(format!("unknown {} flag: {}",
- level.as_str(), lint_name)[]),
+ level.as_str(), lint_name).index(&FullRange)),
}
}
}
if level == Forbid { level = Deny; }
match (level, span) {
- (Warn, Some(sp)) => sess.span_warn(sp, msg[]),
- (Warn, None) => sess.warn(msg[]),
- (Deny, Some(sp)) => sess.span_err(sp, msg[]),
- (Deny, None) => sess.err(msg[]),
+ (Warn, Some(sp)) => sess.span_warn(sp, msg.index(&FullRange)),
+ (Warn, None) => sess.warn(msg.index(&FullRange)),
+ (Deny, Some(sp)) => sess.span_err(sp, msg.index(&FullRange)),
+ (Deny, None) => sess.err(msg.index(&FullRange)),
_ => sess.bug("impossible level in raw_emit_lint"),
}
None => {
self.span_lint(builtin::UNKNOWN_LINTS, span,
format!("unknown `{}` attribute: `{}`",
- level.as_str(), lint_name)[]);
+ level.as_str(), lint_name).as_slice());
continue;
}
}
self.tcx.sess.span_err(span,
format!("{}({}) overruled by outer forbid({})",
level.as_str(), lint_name,
- lint_name)[]);
+ lint_name).index(&FullRange));
} else if now != level {
let src = self.lints.get_level_source(lint_id).1;
self.level_stack.push((lint_id, (now, src)));
impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
fn visit_item(&mut self, it: &ast::Item) {
- self.with_lint_attrs(it.attrs[], |cx| {
+ self.with_lint_attrs(it.attrs.index(&FullRange), |cx| {
run_lints!(cx, check_item, it);
cx.visit_ids(|v| v.visit_item(it));
visit::walk_item(cx, it);
}
fn visit_foreign_item(&mut self, it: &ast::ForeignItem) {
- self.with_lint_attrs(it.attrs[], |cx| {
+ self.with_lint_attrs(it.attrs.index(&FullRange), |cx| {
run_lints!(cx, check_foreign_item, it);
visit::walk_foreign_item(cx, it);
})
}
fn visit_view_item(&mut self, i: &ast::ViewItem) {
- self.with_lint_attrs(i.attrs[], |cx| {
+ self.with_lint_attrs(i.attrs.index(&FullRange), |cx| {
run_lints!(cx, check_view_item, i);
cx.visit_ids(|v| v.visit_view_item(i));
visit::walk_view_item(cx, i);
body: &'v ast::Block, span: Span, id: ast::NodeId) {
match fk {
visit::FkMethod(_, _, m) => {
- self.with_lint_attrs(m.attrs[], |cx| {
+ self.with_lint_attrs(m.attrs.index(&FullRange), |cx| {
run_lints!(cx, check_fn, fk, decl, body, span, id);
cx.visit_ids(|v| {
v.visit_fn(fk, decl, body, span, id);
}
fn visit_ty_method(&mut self, t: &ast::TypeMethod) {
- self.with_lint_attrs(t.attrs[], |cx| {
+ self.with_lint_attrs(t.attrs.index(&FullRange), |cx| {
run_lints!(cx, check_ty_method, t);
visit::walk_ty_method(cx, t);
})
}
fn visit_struct_field(&mut self, s: &ast::StructField) {
- self.with_lint_attrs(s.node.attrs[], |cx| {
+ self.with_lint_attrs(s.node.attrs.index(&FullRange), |cx| {
run_lints!(cx, check_struct_field, s);
visit::walk_struct_field(cx, s);
})
}
fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics) {
- self.with_lint_attrs(v.node.attrs[], |cx| {
+ self.with_lint_attrs(v.node.attrs.index(&FullRange), |cx| {
run_lints!(cx, check_variant, v, g);
visit::walk_variant(cx, v, g);
run_lints!(cx, check_variant_post, v, g);
None => {}
Some(lints) => {
for (lint_id, span, msg) in lints.into_iter() {
- self.span_lint(lint_id.lint, span, msg[])
+ self.span_lint(lint_id.lint, span, msg.index(&FullRange))
}
}
}
let mut cx = Context::new(tcx, krate, exported_items);
// Visit the whole crate.
- cx.with_lint_attrs(krate.attrs[], |cx| {
+ cx.with_lint_attrs(krate.attrs.index(&FullRange), |cx| {
cx.visit_id(ast::CRATE_NODE_ID);
cx.visit_ids(|v| {
v.visited_outermost = true;
for &(lint, span, ref msg) in v.iter() {
tcx.sess.span_bug(span,
format!("unprocessed lint {} at {}: {}",
- lint.as_str(), tcx.map.node_to_string(*id), *msg)[])
+ lint.as_str(), tcx.map.node_to_string(*id), *msg).as_slice())
}
}
}
fn should_link(i: &ast::ViewItem) -> bool {
- !attr::contains_name(i.attrs[], "no_link")
+ !attr::contains_name(i.attrs.index(&FullRange), "no_link")
+
}
struct CrateInfo {
for c in s.chars() {
if c.is_alphanumeric() { continue }
if c == '_' || c == '-' { continue }
- err(format!("invalid character `{}` in crate name: `{}`", c, s)[]);
+ err(format!("invalid character `{}` in crate name: `{}`", c, s).index(&FullRange));
}
match sess {
Some(sess) => sess.abort_if_errors(),
}
}
+
fn register_native_lib(sess: &Session,
span: Option<Span>,
name: String,
match self.extract_crate_info(i) {
Some(info) => {
let (cnum, _, _) = self.resolve_crate(&None,
- info.ident[],
- info.name[],
+ info.ident.index(&FullRange),
+ info.name.index(&FullRange),
None,
i.span,
PathKind::Crate);
match i.node {
ast::ViewItemExternCrate(ident, ref path_opt, id) => {
let ident = token::get_ident(ident);
- debug!("resolving extern crate stmt. ident: {} path_opt: {}",
+ debug!("resolving extern crate stmt. ident: {} path_opt: {:?}",
ident, path_opt);
let name = match *path_opt {
Some((ref path_str, _)) => {
let name = path_str.get().to_string();
- validate_crate_name(Some(self.sess), name[],
+ validate_crate_name(Some(self.sess), name.index(&FullRange),
Some(i.span));
name
}
} else {
self.sess.span_err(m.span,
format!("unknown kind: `{}`",
- k)[]);
+ k).index(&FullRange));
cstore::NativeUnknown
}
}
match self.sess.opts.externs.get(name) {
Some(locs) => {
let found = locs.iter().any(|l| {
- let l = fs::realpath(&Path::new(l[])).ok();
+ let l = fs::realpath(&Path::new(l.index(&FullRange))).ok();
l == source.dylib || l == source.rlib
});
if found {
crate_name: name,
hash: hash.map(|a| &*a),
filesearch: self.sess.target_filesearch(kind),
- triple: self.sess.opts.target_triple[],
+ triple: self.sess.opts.target_triple.index(&FullRange),
root: root,
rejected_via_hash: vec!(),
rejected_via_triple: vec!(),
decoder::get_crate_deps(cdata).iter().map(|dep| {
debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash);
let (local_cnum, _, _) = self.resolve_crate(root,
- dep.name[],
- dep.name[],
+ dep.name.index(&FullRange),
+ dep.name.index(&FullRange),
Some(&dep.hash),
span,
PathKind::Dependency);
pub fn read_plugin_metadata<'b>(&'b mut self,
vi: &'b ast::ViewItem) -> PluginMetadata<'b> {
let info = self.extract_crate_info(vi).unwrap();
- let target_triple = self.sess.opts.target_triple[];
+ let target_triple = self.sess.opts.target_triple.index(&FullRange);
let is_cross = target_triple != config::host_triple();
let mut should_link = info.should_link && !is_cross;
let mut target_only = false;
let mut load_ctxt = loader::Context {
sess: self.sess,
span: vi.span,
- ident: ident[],
- crate_name: name[],
+ ident: ident.index(&FullRange),
+ crate_name: name.index(&FullRange),
hash: None,
filesearch: self.sess.host_filesearch(PathKind::Crate),
triple: config::host_triple(),
};
let dylib = library.dylib.clone();
- let register = should_link && self.existing_match(info.name[], None).is_none();
+ let register = should_link && self.existing_match(info.name.as_slice(), None).is_none();
let metadata = if register {
// Register crate now to avoid double-reading metadata
- let (_, cmd, _) = self.register_crate(&None, info.ident[],
- info.name[], vi.span, library);
+ let (_, cmd, _) = self.register_crate(&None, info.ident.index(&FullRange),
+ info.name.index(&FullRange), vi.span, library);
PMDSource::Registered(cmd)
} else {
// Not registering the crate; just hold on to the metadata
impl<'a> PluginMetadata<'a> {
/// Read exported macros
pub fn exported_macros(&self) -> Vec<ast::MacroDef> {
- let imported_from = Some(token::intern(self.info.ident[]).ident());
- let source_name = format!("<{} macros>", self.info.ident[]);
+ let imported_from = Some(token::intern(self.info.ident.index(&FullRange)).ident());
+ let source_name = format!("<{} macros>", self.info.ident.index(&FullRange));
let mut macros = vec![];
decoder::each_exported_macro(self.metadata.as_slice(),
&*self.sess.cstore.intr,
self.info.ident,
config::host_triple(),
self.sess.opts.target_triple);
- self.sess.span_err(self.vi_span, message[]);
+ self.sess.span_err(self.vi_span, message.index(&FullRange));
self.sess.abort_if_errors();
}
let message = format!("plugin crate `{}` only found in rlib format, \
but must be available in dylib format",
self.info.ident);
- self.sess.span_err(self.vi_span, message[]);
+ self.sess.span_err(self.vi_span, message.index(&FullRange));
// No need to abort because the loading code will just ignore this
// empty dylib.
None
// FIXME #1920: This path is not always correct if the crate is not linked
// into the root namespace.
- let mut r = vec![ast_map::PathMod(token::intern(cdata.name[]))];
+ let mut r = vec![ast_map::PathMod(token::intern(cdata.name.index(&FullRange)))];
r.push_all(path.as_slice());
r
}
let class_doc = expect(tcx.sess.diagnostic(),
decoder::maybe_find_item(class_id.node, all_items),
|| {
- (format!("get_field_type: class ID {} not found",
+ (format!("get_field_type: class ID {:?} not found",
class_id)).to_string()
});
let the_field = expect(tcx.sess.diagnostic(),
decoder::maybe_find_item(def.node, class_doc),
|| {
- (format!("get_field_type: in class {}, field ID {} not found",
+ (format!("get_field_type: in class {:?}, field ID {:?} not found",
class_id,
def)).to_string()
});
let mut ret = None;
reader::tagged_docs(tagged_doc.doc, belt, |elt| {
let pos = u64_from_be_bytes(elt.data, elt.start, 4) as uint;
- if eq_fn(elt.data[elt.start + 4 .. elt.end]) {
+ if eq_fn(elt.data.index(&((elt.start + 4) .. elt.end))) {
ret = Some(reader::doc_at(d.data, pos).unwrap().doc);
false
} else {
items: rbml::Doc<'a>) -> Option<rbml::Doc<'a>> {
fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool {
return u64_from_be_bytes(
- bytes[0u..4u], 0u, 4u) as ast::NodeId
+ bytes.index(&(0u..4u)), 0u, 4u) as ast::NodeId
== item_id;
}
lookup_hash(items,
debug!("Looking up item: {}", id);
let item_doc = lookup_item(id, cdata.data());
let path = item_path(item_doc).init().to_vec();
- match decode_inlined_item.call_mut((cdata, tcx, path, item_doc)) {
+ match decode_inlined_item(cdata, tcx, path, item_doc) {
Ok(ii) => csearch::found(ii),
Err(path) => {
match item_parent_item(item_doc) {
Some(did) => {
let did = translate_def_id(cdata, did);
let parent_item = lookup_item(did.node, cdata.data());
- match decode_inlined_item.call_mut((cdata, tcx, path, parent_item)) {
+ match decode_inlined_item(cdata, tcx, path, parent_item) {
Ok(ii) => csearch::found_parent(did, ii),
Err(_) => csearch::not_found
}
}
reader::tagged_docs(depsdoc, tag_crate_dep, |depdoc| {
let name = docstr(depdoc, tag_crate_dep_crate_name);
- let hash = Svh::new(docstr(depdoc, tag_crate_dep_hash)[]);
+ let hash = Svh::new(docstr(depdoc, tag_crate_dep_hash).index(&FullRange));
deps.push(CrateDep {
cnum: crate_num,
name: name,
}
pub fn encode_def_id(rbml_w: &mut Encoder, id: DefId) {
- rbml_w.wr_tagged_str(tag_def_id, def_to_string(id)[]);
+ rbml_w.wr_tagged_str(tag_def_id, def_to_string(id).index(&FullRange));
}
#[derive(Clone)]
rbml_w.end_tag();
rbml_w.start_tag(tag_mod_child);
- rbml_w.wr_str(s[]);
+ rbml_w.wr_str(s.index(&FullRange));
rbml_w.end_tag();
}
}
None => {
ecx.diag.handler().bug(
- format!("encode_symbol: id not found {}", id)[]);
+ format!("encode_symbol: id not found {}", id).index(&FullRange));
}
}
rbml_w.end_tag();
encode_name(rbml_w, variant.node.name.name);
encode_parent_item(rbml_w, local_def(id));
encode_visibility(rbml_w, variant.node.vis);
- encode_attributes(rbml_w, variant.node.attrs[]);
- encode_repr_attrs(rbml_w, ecx, variant.node.attrs[]);
+ encode_attributes(rbml_w, variant.node.attrs.index(&FullRange));
+ encode_repr_attrs(rbml_w, ecx, variant.node.attrs.index(&FullRange));
let stab = stability::lookup(ecx.tcx, ast_util::local_def(variant.node.id));
encode_stability(rbml_w, stab);
let fields = ty::lookup_struct_fields(ecx.tcx, def_id);
let idx = encode_info_for_struct(ecx,
rbml_w,
- fields[],
+ fields.index(&FullRange),
index);
- encode_struct_fields(rbml_w, fields[], def_id);
+ encode_struct_fields(rbml_w, fields.index(&FullRange), def_id);
encode_index(rbml_w, idx, write_i64);
}
}
exp.name, token::get_name(method_name));
rbml_w.start_tag(tag_items_data_item_reexport);
rbml_w.start_tag(tag_items_data_item_reexport_def_id);
- rbml_w.wr_str(def_to_string(method_def_id)[]);
+ rbml_w.wr_str(def_to_string(method_def_id).index(&FullRange));
rbml_w.end_tag();
rbml_w.start_tag(tag_items_data_item_reexport_name);
rbml_w.wr_str(format!("{}::{}",
exp.name,
- token::get_name(method_name))[]);
+ token::get_name(method_name)).index(&FullRange));
rbml_w.end_tag();
rbml_w.end_tag();
}
id);
rbml_w.start_tag(tag_items_data_item_reexport);
rbml_w.start_tag(tag_items_data_item_reexport_def_id);
- rbml_w.wr_str(def_to_string(exp.def_id)[]);
+ rbml_w.wr_str(def_to_string(exp.def_id).index(&FullRange));
rbml_w.end_tag();
rbml_w.start_tag(tag_items_data_item_reexport_name);
rbml_w.wr_str(exp.name.as_str());
// Encode info about all the module children.
for item in md.items.iter() {
rbml_w.start_tag(tag_mod_child);
- rbml_w.wr_str(def_to_string(local_def(item.id))[]);
+ rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange));
rbml_w.end_tag();
each_auxiliary_node_id(&**item, |auxiliary_node_id| {
rbml_w.start_tag(tag_mod_child);
rbml_w.wr_str(def_to_string(local_def(
- auxiliary_node_id))[]);
+ auxiliary_node_id)).index(&FullRange));
rbml_w.end_tag();
true
});
did, ecx.tcx.map.node_to_string(did));
rbml_w.start_tag(tag_mod_impl);
- rbml_w.wr_str(def_to_string(local_def(did))[]);
+ rbml_w.wr_str(def_to_string(local_def(did)).index(&FullRange));
rbml_w.end_tag();
}
}
ast::Public => 'y',
ast::Inherited => 'i',
};
- rbml_w.wr_str(ch.to_string()[]);
+ rbml_w.wr_str(ch.to_string().index(&FullRange));
rbml_w.end_tag();
}
ty::FnMutUnboxedClosureKind => 'm',
ty::FnOnceUnboxedClosureKind => 'o',
};
- rbml_w.wr_str(ch.to_string()[]);
+ rbml_w.wr_str(ch.to_string().index(&FullRange));
rbml_w.end_tag();
}
rbml_w.end_tag();
rbml_w.wr_tagged_str(tag_region_param_def_def_id,
- def_to_string(param.def_id)[]);
+ def_to_string(param.def_id).index(&FullRange));
rbml_w.wr_tagged_u64(tag_region_param_def_space,
param.space.to_uint() as u64);
parent_id: NodeId,
ast_item_opt: Option<&ast::ImplItem>) {
- debug!("encode_info_for_method: {} {}", m.def_id,
+ debug!("encode_info_for_method: {:?} {:?}", m.def_id,
token::get_name(m.name));
rbml_w.start_tag(tag_items_data_item);
encode_path(rbml_w, impl_path.chain(Some(elem).into_iter()));
match ast_item_opt {
Some(&ast::MethodImplItem(ref ast_method)) => {
- encode_attributes(rbml_w, ast_method.attrs[]);
+ encode_attributes(rbml_w, ast_method.attrs.index(&FullRange));
let any_types = !pty.generics.types.is_empty();
- if any_types || is_default_impl || should_inline(ast_method.attrs[]) {
+ if any_types || is_default_impl || should_inline(ast_method.attrs.index(&FullRange)) {
encode_inlined_item(ecx, rbml_w, IIImplItemRef(local_def(parent_id),
ast_item_opt.unwrap()));
}
impl_path: PathElems,
parent_id: NodeId,
typedef_opt: Option<P<ast::Typedef>>) {
- debug!("encode_info_for_associated_type({},{})",
+ debug!("encode_info_for_associated_type({:?},{:?})",
associated_type.def_id,
token::get_name(associated_type.name));
match typedef_opt {
None => {}
Some(typedef) => {
- encode_attributes(rbml_w, typedef.attrs[]);
+ encode_attributes(rbml_w, typedef.attrs.index(&FullRange));
encode_type(ecx, rbml_w, ty::node_id_to_type(ecx.tcx,
typedef.id));
}
ii: InlinedItemRef) {
let mut eii = ecx.encode_inlined_item.borrow_mut();
let eii: &mut EncodeInlinedItem = &mut *eii;
- eii.call_mut((ecx, rbml_w, ii))
+ eii(ecx, rbml_w, ii)
}
const FN_FAMILY: char = 'f';
encode_path(rbml_w, path);
encode_visibility(rbml_w, vis);
encode_stability(rbml_w, stab);
- encode_attributes(rbml_w, item.attrs[]);
+ encode_attributes(rbml_w, item.attrs.index(&FullRange));
rbml_w.end_tag();
}
ast::ItemConst(_, _) => {
encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
encode_name(rbml_w, item.ident.name);
encode_path(rbml_w, path);
- encode_attributes(rbml_w, item.attrs[]);
- if tps_len > 0u || should_inline(item.attrs[]) {
+ encode_attributes(rbml_w, item.attrs.index(&FullRange));
+ if tps_len > 0u || should_inline(item.attrs.index(&FullRange)) {
encode_inlined_item(ecx, rbml_w, IIItemRef(item));
}
if tps_len == 0 {
encode_info_for_mod(ecx,
rbml_w,
m,
- item.attrs[],
+ item.attrs.index(&FullRange),
item.id,
path,
item.ident,
// Encode all the items in this module.
for foreign_item in fm.items.iter() {
rbml_w.start_tag(tag_mod_child);
- rbml_w.wr_str(def_to_string(local_def(foreign_item.id))[]);
+ rbml_w.wr_str(def_to_string(local_def(foreign_item.id)).index(&FullRange));
rbml_w.end_tag();
}
encode_visibility(rbml_w, vis);
encode_item_variances(rbml_w, ecx, item.id);
encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
encode_name(rbml_w, item.ident.name);
- encode_attributes(rbml_w, item.attrs[]);
- encode_repr_attrs(rbml_w, ecx, item.attrs[]);
+ encode_attributes(rbml_w, item.attrs.index(&FullRange));
+ encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange));
for v in (*enum_definition).variants.iter() {
encode_variant_id(rbml_w, local_def(v.node.id));
}
encode_enum_variant_info(ecx,
rbml_w,
item.id,
- (*enum_definition).variants[],
+ (*enum_definition).variants.index(&FullRange),
index);
}
ast::ItemStruct(ref struct_def, _) => {
class itself */
let idx = encode_info_for_struct(ecx,
rbml_w,
- fields[],
+ fields.index(&FullRange),
index);
/* Index the class*/
encode_item_variances(rbml_w, ecx, item.id);
encode_name(rbml_w, item.ident.name);
- encode_attributes(rbml_w, item.attrs[]);
+ encode_attributes(rbml_w, item.attrs.index(&FullRange));
encode_path(rbml_w, path.clone());
encode_stability(rbml_w, stab);
encode_visibility(rbml_w, vis);
- encode_repr_attrs(rbml_w, ecx, item.attrs[]);
+ encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange));
/* Encode def_ids for each field and method
for methods, write all the stuff get_trait_method
needs to know*/
- encode_struct_fields(rbml_w, fields[], def_id);
+ encode_struct_fields(rbml_w, fields.index(&FullRange), def_id);
encode_inlined_item(ecx, rbml_w, IIItemRef(item));
encode_family(rbml_w, 'i');
encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
encode_name(rbml_w, item.ident.name);
- encode_attributes(rbml_w, item.attrs[]);
+ encode_attributes(rbml_w, item.attrs.index(&FullRange));
encode_unsafety(rbml_w, unsafety);
encode_polarity(rbml_w, polarity);
match ty.node {
encode_generics(rbml_w, ecx, &trait_def.generics, tag_item_generics);
encode_trait_ref(rbml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref);
encode_name(rbml_w, item.ident.name);
- encode_attributes(rbml_w, item.attrs[]);
+ encode_attributes(rbml_w, item.attrs.index(&FullRange));
encode_visibility(rbml_w, vis);
encode_stability(rbml_w, stab);
for &method_def_id in ty::trait_item_def_ids(tcx, def_id).iter() {
rbml_w.end_tag();
rbml_w.start_tag(tag_mod_child);
- rbml_w.wr_str(def_to_string(method_def_id.def_id())[]);
+ rbml_w.wr_str(def_to_string(method_def_id.def_id()).index(&FullRange));
rbml_w.end_tag();
}
encode_path(rbml_w, path.clone());
};
match trait_item {
&ast::RequiredMethod(ref m) => {
- encode_attributes(rbml_w, m.attrs[]);
+ encode_attributes(rbml_w, m.attrs.index(&FullRange));
encode_trait_item(rbml_w);
encode_item_sort(rbml_w, 'r');
encode_method_argument_names(rbml_w, &*m.decl);
}
&ast::ProvidedMethod(ref m) => {
- encode_attributes(rbml_w, m.attrs[]);
+ encode_attributes(rbml_w, m.attrs.index(&FullRange));
encode_trait_item(rbml_w);
encode_item_sort(rbml_w, 'p');
encode_inlined_item(ecx, rbml_w, IITraitItemRef(def_id, trait_item));
&ast::TypeTraitItem(ref associated_type) => {
encode_attributes(rbml_w,
- associated_type.attrs[]);
+ associated_type.attrs.index(&FullRange));
encode_item_sort(rbml_w, 't');
}
}
let mut buckets: Vec<Vec<entry<T>>> = range(0, 256u16).map(|_| Vec::new()).collect();
for elt in index.into_iter() {
let h = hash::hash(&elt.val) as uint;
- buckets[h % 256].push(elt);
+ (&mut buckets[h % 256]).push(elt);
}
rbml_w.start_tag(tag_index);
rbml_w.start_tag(tag_macro_def);
encode_name(rbml_w, def.ident.name);
- encode_attributes(rbml_w, def.attrs[]);
+ encode_attributes(rbml_w, def.attrs.index(&FullRange));
rbml_w.start_tag(tag_macro_def_body);
- rbml_w.wr_str(pprust::tts_to_string(def.body[])[]);
+ rbml_w.wr_str(pprust::tts_to_string(def.body.index(&FullRange)).index(&FullRange));
rbml_w.end_tag();
rbml_w.end_tag();
fn visit_struct_field(&mut self, field: &ast::StructField) {
self.rbml_w.start_tag(tag_struct_field);
self.rbml_w.wr_tagged_u32(tag_struct_field_id, field.node.id);
- encode_attributes(self.rbml_w, field.node.attrs[]);
+ encode_attributes(self.rbml_w, field.node.attrs.index(&FullRange));
self.rbml_w.end_tag();
}
}
rbml_w.start_tag(tag_misc_info_crate_items);
for item in krate.module.items.iter() {
rbml_w.start_tag(tag_mod_child);
- rbml_w.wr_str(def_to_string(local_def(item.id))[]);
+ rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange));
rbml_w.end_tag();
each_auxiliary_node_id(&**item, |auxiliary_node_id| {
rbml_w.start_tag(tag_mod_child);
rbml_w.wr_str(def_to_string(local_def(
- auxiliary_node_id))[]);
+ auxiliary_node_id)).index(&FullRange));
rbml_w.end_tag();
true
});
let mut rbml_w = writer::Encoder::new(wr);
- encode_crate_name(&mut rbml_w, ecx.link_meta.crate_name[]);
+ encode_crate_name(&mut rbml_w, ecx.link_meta.crate_name.index(&FullRange));
encode_crate_triple(&mut rbml_w,
tcx.sess
.opts
.target_triple
- []);
+ .index(&FullRange));
encode_hash(&mut rbml_w, &ecx.link_meta.crate_hash);
encode_dylib_dependency_formats(&mut rbml_w, &ecx);
let mut i = rbml_w.writer.tell().unwrap();
- encode_attributes(&mut rbml_w, krate.attrs[]);
+ encode_attributes(&mut rbml_w, krate.attrs.index(&FullRange));
stats.attr_bytes = rbml_w.writer.tell().unwrap() - i;
i = rbml_w.writer.tell().unwrap();
&Some(ref r) => format!("{} which `{}` depends on",
message, r.ident)
};
- self.sess.span_err(self.span, message[]);
+ self.sess.span_err(self.span, message.index(&FullRange));
if self.rejected_via_triple.len() > 0 {
let mismatches = self.rejected_via_triple.iter();
for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() {
self.sess.fileline_note(self.span,
format!("crate `{}`, path #{}, triple {}: {}",
- self.ident, i+1, got, path.display())[]);
+ self.ident, i+1, got, path.display()).index(&FullRange));
}
}
if self.rejected_via_hash.len() > 0 {
for (i, &CrateMismatch{ ref path, .. }) in mismatches.enumerate() {
self.sess.fileline_note(self.span,
format!("crate `{}` path {}{}: {}",
- self.ident, "#", i+1, path.display())[]);
+ self.ident, "#", i+1, path.display()).index(&FullRange));
}
match self.root {
&None => {}
for (i, path) in r.paths().iter().enumerate() {
self.sess.fileline_note(self.span,
format!("crate `{}` path #{}: {}",
- r.ident, i+1, path.display())[]);
+ r.ident, i+1, path.display()).index(&FullRange));
}
}
}
None => return FileDoesntMatch,
Some(file) => file,
};
- let (hash, rlib) = if file.starts_with(rlib_prefix[]) &&
+ let (hash, rlib) = if file.starts_with(rlib_prefix.index(&FullRange)) &&
file.ends_with(".rlib") {
(file.slice(rlib_prefix.len(), file.len() - ".rlib".len()),
true)
info!("lib candidate: {}", path.display());
let hash_str = hash.to_string();
- let slot = candidates.entry(&hash_str).get().unwrap_or_else(
+ let slot = candidates.entry(hash_str).get().unwrap_or_else(
|vacant_entry| vacant_entry.insert((HashSet::new(), HashSet::new())));
let (ref mut rlibs, ref mut dylibs) = *slot;
if rlib {
_ => {
self.sess.span_err(self.span,
format!("multiple matching crates for `{}`",
- self.crate_name)[]);
+ self.crate_name).index(&FullRange));
self.sess.note("candidates:");
for lib in libraries.iter() {
match lib.dylib {
Some(ref p) => {
self.sess.note(format!("path: {}",
- p.display())[]);
+ p.display()).index(&FullRange));
}
None => {}
}
match lib.rlib {
Some(ref p) => {
self.sess.note(format!("path: {}",
- p.display())[]);
+ p.display()).index(&FullRange));
}
None => {}
}
let data = lib.metadata.as_slice();
let name = decoder::get_crate_name(data);
- note_crate_name(self.sess.diagnostic(), name[]);
+ note_crate_name(self.sess.diagnostic(), name.index(&FullRange));
}
None
}
format!("multiple {} candidates for `{}` \
found",
flavor,
- self.crate_name)[]);
+ self.crate_name).index(&FullRange));
self.sess.span_note(self.span,
format!(r"candidate #1: {}",
ret.as_ref().unwrap()
- .display())[]);
+ .display()).index(&FullRange));
error = 1;
ret = None;
}
error += 1;
self.sess.span_note(self.span,
format!(r"candidate #{}: {}", error,
- lib.display())[]);
+ lib.display()).index(&FullRange));
continue
}
*slot = Some(metadata);
let mut rlibs = HashSet::new();
let mut dylibs = HashSet::new();
{
- let mut locs = locs.iter().map(|l| Path::new(l[])).filter(|loc| {
+ let mut locs = locs.iter().map(|l| Path::new(l.index(&FullRange))).filter(|loc| {
if !loc.exists() {
sess.err(format!("extern location for {} does not exist: {}",
- self.crate_name, loc.display())[]);
+ self.crate_name, loc.display()).index(&FullRange));
return false;
}
let file = match loc.filename_str() {
Some(file) => file,
None => {
sess.err(format!("extern location for {} is not a file: {}",
- self.crate_name, loc.display())[]);
+ self.crate_name, loc.display()).index(&FullRange));
return false;
}
};
return true
} else {
let (ref prefix, ref suffix) = dylibname;
- if file.starts_with(prefix[]) && file.ends_with(suffix[]) {
+ if file.starts_with(prefix.index(&FullRange)) &&
+ file.ends_with(suffix.index(&FullRange)) {
return true
}
}
sess.err(format!("extern location for {} is of an unknown type: {}",
- self.crate_name, loc.display())[]);
+ self.crate_name, loc.display()).index(&FullRange));
false
});
}
pub fn note_crate_name(diag: &SpanHandler, name: &str) {
- diag.handler().note(format!("crate name: {}", name)[]);
+ diag.handler().note(format!("crate name: {}", name).index(&FullRange));
}
impl ArchiveMetadata {
}
let end_pos = st.pos;
st.pos += 1;
- return op(st.data[start_pos..end_pos]);
+ return op(st.data.index(&(start_pos..end_pos)));
}
pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
'&' => ty::RegionTraitStore(parse_region_(st, conv), parse_mutability(st)),
c => {
st.tcx.sess.bug(format!("parse_trait_store(): bad input '{}'",
- c)[])
+ c).index(&FullRange))
}
}
}
}
'[' => {
let def = parse_def_(st, RegionParameter, conv);
- let ident = token::str_to_ident(parse_str(st, ']')[]);
+ let ident = token::str_to_ident(parse_str(st, ']').index(&FullRange));
ty::BrNamed(def, ident.name)
}
'f' => {
assert_eq!(next(st), '|');
let index = parse_u32(st);
assert_eq!(next(st), '|');
- let nm = token::str_to_ident(parse_str(st, ']')[]);
+ let nm = token::str_to_ident(parse_str(st, ']').index(&FullRange));
ty::ReEarlyBound(node_id, space, index, nm.name)
}
'f' => {
let tcx = st.tcx;
match next(st) {
'b' => return tcx.types.bool,
- 'i' => return tcx.types.int,
- 'u' => return tcx.types.uint,
+ 'i' => { /* eat the s of is */ next(st); return tcx.types.int },
+ 'u' => { /* eat the s of us */ next(st); return tcx.types.uint },
'M' => {
match next(st) {
'b' => return tcx.types.u8,
assert_eq!(next(st), '|');
let space = parse_param_space(st);
assert_eq!(next(st), '|');
- let name = token::intern(parse_str(st, ']')[]);
+ let name = token::intern(parse_str(st, ']').index(&FullRange));
return ty::mk_param(tcx, space, index, name);
}
'~' => return ty::mk_uniq(tcx, parse_ty_(st, conv)),
assert_eq!(next(st), '[');
scan(st, |c| c == ']', |bytes| {
let abi_str = str::from_utf8(bytes).unwrap();
- abi::lookup(abi_str[]).expect(abi_str)
+ abi::lookup(abi_str.index(&FullRange)).expect(abi_str)
})
}
panic!();
}
- let crate_part = buf[0u..colon_idx];
- let def_part = buf[colon_idx + 1u..len];
+ let crate_part = buf.index(&(0u..colon_idx));
+ let def_part = buf.index(&((colon_idx + 1u)..len));
let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| s.parse::<uint>()) {
Some(cn) => cn as ast::CrateNum,
- None => panic!("internal error: parse_def_id: crate number expected, found {}",
+ None => panic!("internal error: parse_def_id: crate number expected, found {:?}",
crate_part)
};
let def_num = match str::from_utf8(def_part).ok().and_then(|s| s.parse::<uint>()) {
Some(dn) => dn as ast::NodeId,
- None => panic!("internal error: parse_def_id: id expected, found {}",
+ None => panic!("internal error: parse_def_id: id expected, found {:?}",
def_part)
};
ast::DefId { krate: crate_num, node: def_num }
ty::ty_char => mywrite!(w, "c"),
ty::ty_int(t) => {
match t {
- ast::TyI => mywrite!(w, "i"),
+ ast::TyIs => mywrite!(w, "is"),
ast::TyI8 => mywrite!(w, "MB"),
ast::TyI16 => mywrite!(w, "MW"),
ast::TyI32 => mywrite!(w, "ML"),
}
ty::ty_uint(t) => {
match t {
- ast::TyU => mywrite!(w, "u"),
+ ast::TyUs => mywrite!(w, "us"),
ast::TyU8 => mywrite!(w, "Mb"),
ast::TyU16 => mywrite!(w, "Mw"),
ast::TyU32 => mywrite!(w, "Ml"),
None => {
tcx.sess.span_bug(ast_ty.span,
format!("unbound path {}",
- path.repr(tcx))[])
+ path.repr(tcx)).index(&FullRange))
}
Some(&d) => d
};
e::IIImplItemRef(_, &ast::MethodImplItem(ref m)) => m.id,
e::IIImplItemRef(_, &ast::TypeImplItem(ref ti)) => ti.id,
};
- debug!("> Encoding inlined item: {} ({})",
+ debug!("> Encoding inlined item: {} ({:?})",
ecx.tcx.map.path_to_string(id),
rbml_w.writer.tell());
encode_side_tables_for_ii(ecx, rbml_w, &ii);
rbml_w.end_tag();
- debug!("< Encoded inlined fn: {} ({})",
+ debug!("< Encoded inlined fn: {} ({:?})",
ecx.tcx.map.path_to_string(id),
rbml_w.writer.tell());
}
None => Err(path),
Some(ast_doc) => {
let mut path_as_str = None;
- debug!("> Decoding inlined fn: {}::?",
+ debug!("> Decoding inlined fn: {:?}::?",
{
// Do an Option dance to use the path after it is moved below.
let s = ast_map::path_to_string(ast_map::Values(path.iter()));
path_as_str = Some(s);
- path_as_str.as_ref().map(|x| x[])
+ path_as_str.as_ref().map(|x| x.index(&FullRange))
});
let mut ast_dsr = reader::Decoder::new(ast_doc);
let from_id_range = Decodable::decode(&mut ast_dsr).unwrap();
fn emit_def_id(&mut self, did: ast::DefId);
}
-#[cfg(stage0)]
-impl<S:serialize::Encoder<E>, E> def_id_encoder_helpers for S {
- fn emit_def_id(&mut self, did: ast::DefId) {
- did.encode(self).ok().unwrap()
- }
-}
-
-#[cfg(not(stage0))]
impl<S:serialize::Encoder> def_id_encoder_helpers for S {
fn emit_def_id(&mut self, did: ast::DefId) {
did.encode(self).ok().unwrap()
cdata: &cstore::crate_metadata) -> ast::DefId;
}
-#[cfg(stage0)]
-impl<D:serialize::Decoder<E>, E> def_id_decoder_helpers for D {
- fn read_def_id(&mut self, dcx: &DecodeContext) -> ast::DefId {
- let did: ast::DefId = Decodable::decode(self).ok().unwrap();
- did.tr(dcx)
- }
-
- fn read_def_id_nodcx(&mut self,
- cdata: &cstore::crate_metadata) -> ast::DefId {
- let did: ast::DefId = Decodable::decode(self).ok().unwrap();
- decoder::translate_def_id(cdata, did)
- }
-}
-
-#[cfg(not(stage0))]
impl<D:serialize::Decoder> def_id_decoder_helpers for D {
fn read_def_id(&mut self, dcx: &DecodeContext) -> ast::DefId {
let did: ast::DefId = Decodable::decode(self).ok().unwrap();
NominalType | TypeWithId | RegionParameter => dcx.tr_def_id(did),
TypeParameter | UnboxedClosureSource => dcx.tr_intern_def_id(did)
};
- debug!("convert_def_id(source={}, did={})={}", source, did, r);
+ debug!("convert_def_id(source={:?}, did={:?})={:?}", source, did, r);
return r;
}
}
None => {
dcx.tcx.sess.bug(
format!("unknown tag found in side tables: {:x}",
- tag)[]);
+ tag).index(&FullRange));
}
Some(value) => {
let val_doc = entry_doc.get(c::tag_table_val as uint);
_ => {
dcx.tcx.sess.bug(
format!("unknown tag found in side tables: {:x}",
- tag)[]);
+ tag).index(&FullRange));
}
}
}
let mut cond_exit = discr_exit;
for arm in arms.iter() {
cond_exit = self.add_dummy_node(&[cond_exit]); // 2
- let pats_exit = self.pats_any(arm.pats[],
+ let pats_exit = self.pats_any(arm.pats.index(&FullRange),
cond_exit); // 3
let guard_exit = self.opt_expr(&arm.guard,
pats_exit); // 4
let inputs = inline_asm.inputs.iter();
let outputs = inline_asm.outputs.iter();
let post_inputs = self.exprs(inputs.map(|a| {
- debug!("cfg::construct InlineAsm id:{} input:{}", expr.id, a);
+ debug!("cfg::construct InlineAsm id:{} input:{:?}", expr.id, a);
let &(_, ref expr) = a;
&**expr
}), pred);
let post_outputs = self.exprs(outputs.map(|a| {
- debug!("cfg::construct InlineAsm id:{} output:{}", expr.id, a);
+ debug!("cfg::construct InlineAsm id:{} output:{:?}", expr.id, a);
let &(_, ref expr, _) = a;
&**expr
}), post_inputs);
let func_or_rcvr_exit = self.expr(func_or_rcvr, pred);
let ret = self.straightline(call_expr, func_or_rcvr_exit, args);
- if return_ty == ty::FnDiverging {
+ if return_ty.diverges() {
self.add_node(ast::DUMMY_NODE_ID, &[])
} else {
ret
self.tcx.sess.span_bug(
expr.span,
format!("no loop scope for id {}",
- loop_id)[]);
+ loop_id).index(&FullRange));
}
r => {
self.tcx.sess.span_bug(
expr.span,
- format!("bad entry `{}` in def_map for label",
- r)[]);
+ format!("bad entry `{:?}` in def_map for label",
+ r).index(&FullRange));
}
}
}
}
impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {
- fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(self.name[]).unwrap() }
+ fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(self.name.index(&FullRange)).unwrap() }
fn node_id(&'a self, &(i,_): &Node<'a>) -> dot::Id<'a> {
dot::Id::new(format!("N{}", i.node_id())).unwrap()
let s = self.ast_map.node_to_string(node_id);
// left-aligns the lines
let s = replace_newline_with_backslash_l(s);
- label.push_str(format!("exiting scope_{} {}", i, s[])[]);
+ label.push_str(format!("exiting scope_{} {}",
+ i,
+ s.index(&FullRange)).index(&FullRange));
}
dot::LabelText::EscStr(label.into_cow())
}
DefStruct(_) | DefVariant(_, _, _) => {}
def => {
- debug!("(checking const) found bad def: {}", def);
+ debug!("(checking const) found bad def: {:?}", def);
span_err!(v.tcx.sess, e.span, E0014,
"paths in constants may only refer to constants \
or functions");
Loop => {}
Closure => {
self.sess.span_err(span,
- format!("`{}` inside of a closure", name)[]);
+ format!("`{}` inside of a closure", name).index(&FullRange));
}
Normal => {
self.sess.span_err(span,
- format!("`{}` outside of loop", name)[]);
+ format!("`{}` outside of loop", name).index(&FullRange));
}
}
}
/// Pretty-printer for matrices of patterns, example:
/// ++++++++++++++++++++++++++
-/// + _ + [] +
+/// + _ + .index(&FullRange) +
/// ++++++++++++++++++++++++++
/// + true + [First] +
/// ++++++++++++++++++++++++++
// First, check legality of move bindings.
check_legality_of_move_bindings(cx,
arm.guard.is_some(),
- arm.pats[]);
+ arm.pats.index(&FullRange));
// Second, if there is a guard on each arm, make sure it isn't
// assigning or borrowing anything mutably.
}
// Fourth, check for unreachable arms.
- check_arms(cx, inlined_arms[], source);
+ check_arms(cx, inlined_arms.index(&FullRange), source);
// Finally, check if the whole match expression is exhaustive.
// Check for empty enum, because is_useful only works on inhabited types.
pat.span,
format!("refutable pattern in `for` loop binding: \
`{}` not covered",
- pat_to_string(uncovered_pat))[]);
+ pat_to_string(uncovered_pat)).index(&FullRange));
});
// Check legality of move bindings.
for pat in pats.iter() {
let v = vec![&**pat];
- match is_useful(cx, &seen, v[], LeaveOutWitness) {
+ match is_useful(cx, &seen, v.index(&FullRange), LeaveOutWitness) {
NotUseful => {
match source {
ast::MatchSource::IfLetDesugar { .. } => {
fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) {
match is_useful(cx, matrix, &[DUMMY_WILD_PAT], ConstructWitness) {
UsefulWithWitness(pats) => {
- let witness = match pats[] {
+ let witness = match pats.index(&FullRange) {
[ref witness] => &**witness,
[] => DUMMY_WILD_PAT,
_ => unreachable!()
witness: WitnessPreference)
-> Usefulness {
let &Matrix(ref rows) = matrix;
- debug!("{:}", matrix);
+ debug!("{:?}", matrix);
if rows.len() == 0u {
return match witness {
ConstructWitness => UsefulWithWitness(vec!()),
UsefulWithWitness(pats) => UsefulWithWitness({
let arity = constructor_arity(cx, &c, left_ty);
let mut result = {
- let pat_slice = pats[];
+ let pat_slice = pats.index(&FullRange);
let subpats: Vec<_> = range(0, arity).map(|i| {
pat_slice.get(i).map_or(DUMMY_WILD_PAT, |p| &**p)
}).collect();
witness: WitnessPreference) -> Usefulness {
let arity = constructor_arity(cx, &ctor, lty);
let matrix = Matrix(m.iter().filter_map(|r| {
- specialize(cx, r[], &ctor, 0u, arity)
+ specialize(cx, r.index(&FullRange), &ctor, 0u, arity)
}).collect());
match specialize(cx, v, &ctor, 0u, arity) {
- Some(v) => is_useful(cx, &matrix, v[], witness),
+ Some(v) => is_useful(cx, &matrix, v.index(&FullRange), witness),
None => NotUseful
}
}
/// This computes the arity of a constructor. The arity of a constructor
/// is how many subpattern patterns of that constructor should be expanded to.
///
-/// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3.
+/// For instance, a tuple pattern (_, 42u, Some(.index(&FullRange))) has the arity of 3.
/// A struct pattern's arity is the number of fields it contains, etc.
pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uint {
match ty.sty {
}
};
head.map(|mut head| {
- head.push_all(r[..col]);
- head.push_all(r[col + 1..]);
+ head.push_all(r.index(&(0..col)));
+ head.push_all(r.index(&((col + 1)..)));
head
})
}
cx.tcx.sess.span_bug(
p.span,
format!("binding pattern {} is not an \
- identifier: {}",
+ identifier: {:?}",
p.id,
- p.node)[]);
+ p.node).index(&FullRange));
}
}
}
span: Span,
cmt: mc::cmt<'tcx>,
_: euv::ConsumeMode) {
- debug!("consume; cmt: {}; type: {}", *cmt, ty_to_string(self.tcx, cmt.ty));
+ debug!("consume; cmt: {:?}; type: {}", *cmt, ty_to_string(self.tcx, cmt.ty));
if !ty::type_is_sized(self.param_env, span, cmt.ty) {
span_err!(self.tcx.sess, span, E0161,
"cannot move a value of type {0}: the size of {0} cannot be statically determined",
};
self.tcx.sess.span_err(e.span, format!("mutable statics are not allowed \
- to have {}", suffix)[]);
+ to have {}", suffix).index(&FullRange));
}
fn check_static_type(&self, e: &ast::Expr) {
ty::ty_enum(did, _) if ty::has_dtor(self.tcx, did) => {
self.tcx.sess.span_err(e.span,
format!("{} are not allowed to have \
- destructors", self.msg())[])
+ destructors", self.msg()).index(&FullRange))
}
_ => {}
}
let msg = "constants cannot refer to other statics, \
insert an intermediate constant \
instead";
- self.tcx.sess.span_err(e.span, msg[]);
+ self.tcx.sess.span_err(e.span, msg.index(&FullRange));
}
_ => {}
}
_ => {
self.sess.span_err(e.span,
format!("expected item, found {}",
- self.ast_map.node_to_string(def_id.node))[]);
+ self.ast_map.node_to_string(def_id.node)).index(&FullRange));
return;
},
}
// target uses". This _includes_ integer-constants, plus the following
// constructors:
//
-// fixed-size vectors and strings: [] and ""/_
+// fixed-size vectors and strings: .index(&FullRange) and ""/_
// vector and string slices: &[] and &""
// tuples: (,)
// enums: foo(...)
None => None,
Some(ast_map::NodeItem(it)) => match it.node {
ast::ItemEnum(ast::EnumDef { ref variants }, _) => {
- variant_expr(variants[], variant_def.node)
+ variant_expr(variants.index(&FullRange), variant_def.node)
}
_ => None
},
// NOTE this doesn't do the right thing, it compares inlined
// NodeId's to the original variant_def's NodeId, but they
// come from different crates, so they will likely never match.
- variant_expr(variants[], variant_def.node).map(|e| e.id)
+ variant_expr(variants.index(&FullRange), variant_def.node).map(|e| e.id)
}
_ => None
},
ast::ExprCall(ref callee, ref args) => {
let def = tcx.def_map.borrow()[callee.id].clone();
- if let Vacant(entry) = tcx.def_map.borrow_mut().entry(&expr.id) {
+ if let Vacant(entry) = tcx.def_map.borrow_mut().entry(expr.id) {
entry.insert(def);
}
let path = match def {
pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val {
match eval_const_expr_partial(tcx, e) {
Ok(r) => r,
- Err(s) => tcx.sess.span_fatal(e.span, s[])
+ Err(s) => tcx.sess.span_fatal(e.span, s.index(&FullRange))
}
}
eval_const_expr_partial(tcx, &**base)
.and_then(|val| define_casts!(val, {
- ty::ty_int(ast::TyI) => (int, const_int, i64),
+ ty::ty_int(ast::TyIs) => (int, const_int, i64),
ty::ty_int(ast::TyI8) => (i8, const_int, i64),
ty::ty_int(ast::TyI16) => (i16, const_int, i64),
ty::ty_int(ast::TyI32) => (i32, const_int, i64),
ty::ty_int(ast::TyI64) => (i64, const_int, i64),
- ty::ty_uint(ast::TyU) => (uint, const_uint, u64),
+ ty::ty_uint(ast::TyUs) => (uint, const_uint, u64),
ty::ty_uint(ast::TyU8) => (u8, const_uint, u64),
ty::ty_uint(ast::TyU16) => (u16, const_uint, u64),
ty::ty_uint(ast::TyU32) => (u32, const_uint, u64),
let words_per_id = (bits_per_id + uint::BITS - 1) / uint::BITS;
let num_nodes = cfg.graph.all_nodes().len();
- debug!("DataFlowContext::new(analysis_name: {}, id_range={}, \
+ debug!("DataFlowContext::new(analysis_name: {}, id_range={:?}, \
bits_per_id={}, words_per_id={}) \
num_nodes: {}",
analysis_name, id_range, bits_per_id, words_per_id,
fn apply_gen_kill(&self, cfgidx: CFGIndex, bits: &mut [uint]) {
//! Applies the gen and kill sets for `cfgidx` to `bits`
- debug!("{} apply_gen_kill(cfgidx={}, bits={}) [before]",
+ debug!("{} apply_gen_kill(cfgidx={:?}, bits={}) [before]",
self.analysis_name, cfgidx, mut_bits_to_string(bits));
assert!(self.bits_per_id > 0);
let kills = self.kills.slice(start, end);
bitwise(bits, kills, &Subtract);
- debug!("{} apply_gen_kill(cfgidx={}, bits={}) [after]",
+ debug!("{} apply_gen_kill(cfgidx={:?}, bits={}) [after]",
self.analysis_name, cfgidx, mut_bits_to_string(bits));
}
let mut t = on_entry.to_vec();
self.apply_gen_kill(cfgidx, t.as_mut_slice());
temp_bits = t;
- temp_bits[]
+ temp_bits.index(&FullRange)
}
};
- debug!("{} each_bit_for_node({}, cfgidx={}) bits={}",
+ debug!("{} each_bit_for_node({:?}, cfgidx={:?}) bits={}",
self.analysis_name, e, cfgidx, bits_to_string(slice));
self.each_bit(slice, f)
}
}
}
None => {
- debug!("{} add_kills_from_flow_exits flow_exit={} \
+ debug!("{} add_kills_from_flow_exits flow_exit={:?} \
no cfg_idx for exiting_scope={}",
self.analysis_name, flow_exit, node_id);
}
if changed {
let bits = self.kills.slice_mut(start, end);
- debug!("{} add_kills_from_flow_exits flow_exit={} bits={} [before]",
+ debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [before]",
self.analysis_name, flow_exit, mut_bits_to_string(bits));
- bits.clone_from_slice(orig_kills[]);
- debug!("{} add_kills_from_flow_exits flow_exit={} bits={} [after]",
+ bits.clone_from_slice(orig_kills.index(&FullRange));
+ debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [after]",
self.analysis_name, flow_exit, mut_bits_to_string(bits));
}
true
assert!(self.dfcx.bits_per_id > 0);
cfg.graph.each_node(|node_index, node| {
- debug!("DataFlowContext::walk_cfg idx={} id={} begin in_out={}",
+ debug!("DataFlowContext::walk_cfg idx={:?} id={} begin in_out={}",
node_index, node.data.id, bits_to_string(in_out));
let (start, end) = self.dfcx.compute_id_range(node_index);
edge: &cfg::CFGEdge) {
let source = edge.source();
let cfgidx = edge.target();
- debug!("{} propagate_bits_into_entry_set_for(pred_bits={}, {} to {})",
+ debug!("{} propagate_bits_into_entry_set_for(pred_bits={}, {:?} to {:?})",
self.dfcx.analysis_name, bits_to_string(pred_bits), source, cfgidx);
assert!(self.dfcx.bits_per_id > 0);
bitwise(on_entry, pred_bits, &self.dfcx.oper)
};
if changed {
- debug!("{} changed entry set for {} to {}",
+ debug!("{} changed entry set for {:?} to {}",
self.dfcx.analysis_name, cfgidx,
bits_to_string(self.dfcx.on_entry.slice(start, end)));
self.changed = true;
let mut v = word;
for _ in range(0u, uint::BYTES) {
result.push(sep);
- result.push_str(format!("{:02x}", v & 0xFF)[]);
+ result.push_str(format!("{:02x}", v & 0xFF).index(&FullRange));
v >>= 8;
sep = '-';
}
let src = sess.cstore.get_used_crate_source(cnum).unwrap();
if src.rlib.is_some() { return }
sess.err(format!("dependency `{}` not found in rlib format",
- data.name)[]);
+ data.name).index(&FullRange));
});
return Vec::new();
}
add_library(sess, cnum, cstore::RequireDynamic, &mut formats);
let deps = csearch::get_dylib_dependency_formats(&sess.cstore, cnum);
for &(depnum, style) in deps.iter() {
- debug!("adding {}: {}", style,
+ debug!("adding {:?}: {}", style,
sess.cstore.get_crate_data(depnum).name.clone());
add_library(sess, depnum, style, &mut formats);
}
match kind {
cstore::RequireStatic => "rlib",
cstore::RequireDynamic => "dylib",
- })[]);
+ }).index(&FullRange));
}
}
}
let data = sess.cstore.get_crate_data(cnum);
sess.err(format!("cannot satisfy dependencies so `{}` only \
shows up once",
- data.name)[]);
+ data.name).index(&FullRange));
sess.help("having upstream crates all available in one format \
will likely make this go away");
}
use middle::ty::{MethodStatic, MethodStaticUnboxedClosure};
use util::ppaux::Repr;
-use std::kinds;
+use std::marker;
use syntax::{ast, ast_util};
use syntax::ptr::P;
use syntax::codemap::Span;
Conflicting,
}
-impl<T> kinds::Copy for TrackMatchMode<T> {}
+impl<T> marker::Copy for TrackMatchMode<T> {}
impl<T> TrackMatchMode<T> {
// Builds up the whole match mode for a pattern from its constituent
}
ast::ExprIndex(ref lhs, ref rhs) => { // lhs[rhs]
- match rhs.node {
- ast::ExprRange(ref start, ref end) => {
- // Hacked slicing syntax (KILLME).
- let args = match (start, end) {
- (&Some(ref e1), &Some(ref e2)) => vec![&**e1, &**e2],
- (&Some(ref e), &None) => vec![&**e],
- (&None, &Some(ref e)) => vec![&**e],
- (&None, &None) => Vec::new()
- };
- let overloaded =
- self.walk_overloaded_operator(expr, &**lhs, args, PassArgs::ByRef);
- assert!(overloaded);
- }
- _ => {
- if !self.walk_overloaded_operator(expr,
- &**lhs,
- vec![&**rhs],
- PassArgs::ByRef) {
- self.select_from_expr(&**lhs);
- self.consume_expr(&**rhs);
- }
- }
+ if !self.walk_overloaded_operator(expr,
+ &**lhs,
+ vec![&**rhs],
+ PassArgs::ByRef) {
+ self.select_from_expr(&**lhs);
+ self.consume_expr(&**rhs);
}
}
None => {}
Some(method_ty) => {
let cmt = return_if_err!(self.mc.cat_expr_autoderefd(expr, i));
- let self_ty = ty::ty_fn_args(method_ty)[0];
+
+ // the method call infrastructure should have
+ // replaced all late-bound regions with variables:
+ let self_ty = ty::ty_fn_sig(method_ty).input(0);
+ let self_ty = ty::assert_no_late_bound_regions(self.tcx(), &self_ty);
+
let (m, r) = match self_ty.sty {
ty::ty_rptr(r, ref m) => (m.mutbl, r),
_ => self.tcx().sess.span_bug(expr.span,
format!("bad overloaded deref type {}",
- method_ty.repr(self.tcx()))[])
+ method_ty.repr(self.tcx())).index(&FullRange))
};
let bk = ty::BorrowKind::from_mutbl(m);
self.delegate.borrow(expr.id, expr.span, cmt,
if pat_util::pat_is_binding(def_map, pat) {
let tcx = typer.tcx();
- debug!("binding cmt_pat={} pat={} match_mode={}",
+ debug!("binding cmt_pat={} pat={} match_mode={:?}",
cmt_pat.repr(tcx),
pat.repr(tcx),
match_mode);
// pattern.
if !tcx.sess.has_errors() {
- let msg = format!("Pattern has unexpected type: {} and type {}",
+ let msg = format!("Pattern has unexpected type: {:?} and type {}",
def,
cmt_pat.ty.repr(tcx));
- tcx.sess.span_bug(pat.span, msg[])
+ tcx.sess.span_bug(pat.span, msg.as_slice())
}
}
// reported.
if !tcx.sess.has_errors() {
- let msg = format!("Pattern has unexpected def: {} and type {}",
+ let msg = format!("Pattern has unexpected def: {:?} and type {}",
def,
cmt_pat.ty.repr(tcx));
- tcx.sess.span_bug(pat.span, msg[])
+ tcx.sess.span_bug(pat.span, msg.index(&FullRange))
}
}
}
impl<E: Show> Show for Edge<E> {
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
- write!(f, "Edge {{ next_edge: [{}, {}], source: {}, target: {}, data: {} }}",
+ write!(f, "Edge {{ next_edge: [{:?}, {:?}], source: {:?}, target: {:?}, data: {:?} }}",
self.next_edge[0], self.next_edge[1], self.source,
self.target, self.data)
}
graph.each_incoming_edge(start_index, |edge_index, edge| {
assert!(graph.edge_data(edge_index) == &edge.data);
assert!(counter < expected_incoming.len());
- debug!("counter={} expected={} edge_index={} edge={}",
+ debug!("counter={:?} expected={:?} edge_index={:?} edge={:?}",
counter, expected_incoming[counter], edge_index, edge);
match expected_incoming[counter] {
(ref e, ref n) => {
graph.each_outgoing_edge(start_index, |edge_index, edge| {
assert!(graph.edge_data(edge_index) == &edge.data);
assert!(counter < expected_outgoing.len());
- debug!("counter={} expected={} edge_index={} edge={}",
+ debug!("counter={:?} expected={:?} edge_index={:?} edge={:?}",
counter, expected_outgoing[counter], edge_index, edge);
match expected_outgoing[counter] {
(ref e, ref n) => {
ty::mt{ty: ty, mutbl: mt_b.mutbl});
try!(self.get_ref().infcx.try(|_| sub.tys(ty, b)));
debug!("Success, coerced with AutoDerefRef(1, \
- AutoPtr(AutoUnsize({})))", kind);
+ AutoPtr(AutoUnsize({:?})))", kind);
Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1,
autoref: Some(ty::AutoPtr(r_borrow, mt_b.mutbl,
ty::mt{ty: ty, mutbl: mt_b.mutbl});
try!(self.get_ref().infcx.try(|_| sub.tys(ty, b)));
debug!("Success, coerced with AutoDerefRef(1, \
- AutoPtr(AutoUnsize({})))", kind);
+ AutoPtr(AutoUnsize({:?})))", kind);
Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1,
autoref: Some(ty::AutoUnsafe(mt_b.mutbl,
let ty = ty::mk_uniq(self.tcx(), ty);
try!(self.get_ref().infcx.try(|_| sub.tys(ty, b)));
debug!("Success, coerced with AutoDerefRef(1, \
- AutoUnsizeUniq({}))", kind);
+ AutoUnsizeUniq({:?}))", kind);
Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1,
autoref: Some(ty::AutoUnsizeUniq(kind))
a: Ty<'tcx>,
ty_b: Ty<'tcx>)
-> Option<(Ty<'tcx>, ty::UnsizeKind<'tcx>)> {
- debug!("unsize_ty(a={}, ty_b={})", a, ty_b.repr(self.tcx()));
+ debug!("unsize_ty(a={:?}, ty_b={})", a, ty_b.repr(self.tcx()));
let tcx = self.tcx();
{
let tcx = self.tcx();
- debug!("coerce_borrowed_object(a={}, b={}, b_mutbl={})",
+ debug!("coerce_borrowed_object(a={}, b={}, b_mutbl={:?})",
a.repr(tcx),
b.repr(tcx), b_mutbl);
{
let tcx = self.tcx();
- debug!("coerce_unsafe_object(a={}, b={}, b_mutbl={})",
+ debug!("coerce_unsafe_object(a={}, b={}, b_mutbl={:?})",
a.repr(tcx),
b.repr(tcx), b_mutbl);
match a.sty {
ty::ty_rptr(_, ty::mt{ty, mutbl}) => match ty.sty {
ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => {
- debug!("mutbl={} b_mutbl={}", mutbl, b_mutbl);
+ debug!("mutbl={:?} b_mutbl={:?}", mutbl, b_mutbl);
let tr = ty::mk_trait(tcx, principal.clone(), bounds.clone());
try!(self.subtype(mk_ty(tr), b));
Ok(Some(AdjustDerefRef(AutoDerefRef {
for _ in a_regions.iter() {
invariance.push(ty::Invariant);
}
- invariance[]
+ invariance.index(&FullRange)
}
};
a: ty::TraitStore,
b: ty::TraitStore)
-> cres<'tcx, ty::TraitStore> {
- debug!("{}.trait_stores(a={}, b={})", self.tag(), a, b);
+ debug!("{}.trait_stores(a={:?}, b={:?})", self.tag(), a, b);
match (a, b) {
(ty::RegionTraitStore(a_r, a_m),
let tcx = this.infcx().tcx;
let a_sty = &a.sty;
let b_sty = &b.sty;
- debug!("super_tys: a_sty={} b_sty={}", a_sty, b_sty);
+ debug!("super_tys: a_sty={:?} b_sty={:?}", a_sty, b_sty);
return match (a_sty, b_sty) {
// The "subtype" ought to be handling cases involving var:
(&ty::ty_infer(TyVar(_)), _) |
format!("{}: bot and var types should have been handled ({},{})",
this.tag(),
a.repr(this.infcx().tcx),
- b.repr(this.infcx().tcx))[]);
+ b.repr(this.infcx().tcx)).index(&FullRange));
}
(&ty::ty_err, _) | (_, &ty::ty_err) => {
(&ty::ty_trait(ref a_),
&ty::ty_trait(ref b_)) => {
- debug!("Trying to match traits {} and {}", a, b);
+ debug!("Trying to match traits {:?} and {:?}", a, b);
let principal = try!(this.binders(&a_.principal, &b_.principal));
let bounds = try!(this.existential_bounds(&a_.bounds, &b_.bounds));
Ok(ty::mk_trait(tcx, principal, bounds))
Some(e) => e,
};
- debug!("instantiate(a_ty={} dir={} b_vid={})",
+ debug!("instantiate(a_ty={} dir={:?} b_vid={})",
a_ty.repr(tcx),
dir,
b_vid.repr(tcx));
self.generalize(a_ty, b_vid, true)
}
});
- debug!("instantiate(a_ty={}, dir={}, \
+ debug!("instantiate(a_ty={}, dir={:?}, \
b_vid={}, generalized_ty={})",
a_ty.repr(tcx), dir, b_vid.repr(tcx),
generalized_ty.repr(tcx));
self.tcx().sess.span_bug(
self.span,
format!("Encountered early bound region when generalizing: {}",
- r.repr(self.tcx()))[]);
+ r.repr(self.tcx())).index(&FullRange));
}
// Always make a fresh region variable for skolemized regions;
ref trace_origins,
ref same_regions) => {
if !same_regions.is_empty() {
- self.report_processed_errors(var_origins[],
- trace_origins[],
- same_regions[]);
+ self.report_processed_errors(var_origins.index(&FullRange),
+ trace_origins.index(&FullRange),
+ same_regions.index(&FullRange));
}
}
}
}
}
let pe = ProcessedErrors(var_origins, trace_origins, same_regions);
- debug!("errors processed: {}", pe);
+ debug!("errors processed: {:?}", pe);
processed_errors.push(pe);
}
return processed_errors;
sub: Region,
sup: Region)
-> Option<FreeRegionsFromSameFn> {
- debug!("free_regions_from_same_fn(sub={}, sup={})", sub, sup);
+ debug!("free_regions_from_same_fn(sub={:?}, sup={:?})", sub, sup);
let (scope_id, fr1, fr2) = match (sub, sup) {
(ReFree(fr1), ReFree(fr2)) => {
if fr1.scope != fr2.scope {
format!("{}: {} ({})",
message_root_str,
expected_found_str,
- ty::type_err_to_str(self.tcx, terr))[]);
+ ty::type_err_to_str(self.tcx, terr)).index(&FullRange));
match trace.origin {
infer::MatchExpressionArm(_, arm_span) =>
// Does the required lifetime have a nice name we can print?
self.tcx.sess.span_err(
origin.span(),
- format!("{} may not live long enough", labeled_user_string)[]);
+ format!("{} may not live long enough", labeled_user_string).index(&FullRange));
self.tcx.sess.span_help(
origin.span(),
format!(
"consider adding an explicit lifetime bound `{}: {}`...",
bound_kind.user_string(self.tcx),
- sub.user_string(self.tcx))[]);
+ sub.user_string(self.tcx)).index(&FullRange));
}
ty::ReStatic => {
// Does the required lifetime have a nice name we can print?
self.tcx.sess.span_err(
origin.span(),
- format!("{} may not live long enough", labeled_user_string)[]);
+ format!("{} may not live long enough", labeled_user_string).index(&FullRange));
self.tcx.sess.span_help(
origin.span(),
format!(
"consider adding an explicit lifetime bound `{}: 'static`...",
- bound_kind.user_string(self.tcx))[]);
+ bound_kind.user_string(self.tcx)).index(&FullRange));
}
_ => {
origin.span(),
format!(
"{} may not live long enough",
- labeled_user_string)[]);
+ labeled_user_string).index(&FullRange));
self.tcx.sess.span_help(
origin.span(),
format!(
"consider adding an explicit lifetime bound for `{}`",
- bound_kind.user_string(self.tcx))[]);
+ bound_kind.user_string(self.tcx)).index(&FullRange));
note_and_explain_region(
self.tcx,
- format!("{} must be valid for ", labeled_user_string)[],
+ format!("{} must be valid for ", labeled_user_string).index(&FullRange),
sub,
"...");
}
ty::local_var_name_str(self.tcx,
upvar_id.var_id)
.get()
- .to_string())[]);
+ .to_string()).index(&FullRange));
note_and_explain_region(
self.tcx,
"...the borrowed pointer is valid for ",
ty::local_var_name_str(self.tcx,
upvar_id.var_id)
.get()
- .to_string())[],
+ .to_string()).index(&FullRange),
sup,
"");
}
outlive the enclosing closure",
ty::local_var_name_str(self.tcx,
id).get()
- .to_string())[]);
+ .to_string()).index(&FullRange));
note_and_explain_region(
self.tcx,
"captured variable is valid for ",
span,
format!("the type `{}` does not fulfill the \
required lifetime",
- self.ty_to_string(ty))[]);
+ self.ty_to_string(ty)).index(&FullRange));
note_and_explain_region(self.tcx,
"type must outlive ",
sub,
span,
format!("the type `{}` (provided as the value of \
a type parameter) is not valid at this point",
- self.ty_to_string(ty))[]);
+ self.ty_to_string(ty)).index(&FullRange));
note_and_explain_region(self.tcx,
"type must outlive ",
sub,
span,
format!("type of expression contains references \
that are not valid during the expression: `{}`",
- self.ty_to_string(t))[]);
+ self.ty_to_string(t)).index(&FullRange));
note_and_explain_region(
self.tcx,
"type is only valid for ",
span,
format!("in type `{}`, reference has a longer lifetime \
than the data it references",
- self.ty_to_string(ty))[]);
+ self.ty_to_string(ty)).index(&FullRange));
note_and_explain_region(
self.tcx,
"the pointer is valid for ",
let (fn_decl, generics, unsafety, ident, expl_self, span)
= node_inner.expect("expect item fn");
let taken = lifetimes_in_scope(self.tcx, scope_id);
- let life_giver = LifeGiver::with_taken(taken[]);
+ let life_giver = LifeGiver::with_taken(taken.index(&FullRange));
let rebuilder = Rebuilder::new(self.tcx, fn_decl, expl_self,
generics, same_regions, &life_giver);
let (fn_decl, expl_self, generics) = rebuilder.rebuild();
}
expl_self_opt = self.rebuild_expl_self(expl_self_opt, lifetime,
&anon_nums, ®ion_names);
- inputs = self.rebuild_args_ty(inputs[], lifetime,
+ inputs = self.rebuild_args_ty(inputs.index(&FullRange), lifetime,
&anon_nums, ®ion_names);
output = self.rebuild_output(&output, lifetime, &anon_nums, ®ion_names);
ty_params = self.rebuild_ty_params(ty_params, lifetime,
names.push(lt_name);
}
names.sort();
- let name = token::str_to_ident(names[0][]).name;
+ let name = token::str_to_ident(names[0].index(&FullRange)).name;
return (name_to_dummy_lifetime(name), Kept);
}
return (self.life_giver.give_lifetime(), Fresh);
.sess
.fatal(format!(
"unbound path {}",
- pprust::path_to_string(path))[])
+ pprust::path_to_string(path)).index(&FullRange))
}
Some(&d) => d
};
opt_explicit_self, generics);
let msg = format!("consider using an explicit lifetime \
parameter as shown: {}", suggested_fn);
- self.tcx.sess.span_help(span, msg[]);
+ self.tcx.sess.span_help(span, msg.index(&FullRange));
}
fn report_inference_failure(&self,
var_origin.span(),
format!("cannot infer an appropriate lifetime{} \
due to conflicting requirements",
- var_description)[]);
+ var_description).index(&FullRange));
}
fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) {
self.tcx.sess.span_note(
trace.origin.span(),
format!("...so that {} ({})",
- desc, values_str)[]);
+ desc, values_str).index(&FullRange));
}
None => {
// Really should avoid printing this error at
// doing right now. - nmatsakis
self.tcx.sess.span_note(
trace.origin.span(),
- format!("...so that {}", desc)[]);
+ format!("...so that {}", desc).index(&FullRange));
}
}
}
"...so that closure can access `{}`",
ty::local_var_name_str(self.tcx, upvar_id.var_id)
.get()
- .to_string())[])
+ .to_string()).index(&FullRange))
}
infer::InfStackClosure(span) => {
self.tcx.sess.span_note(
does not outlive the enclosing closure",
ty::local_var_name_str(
self.tcx,
- id).get().to_string())[]);
+ id).get().to_string()).index(&FullRange));
}
infer::IndexSlice(span) => {
self.tcx.sess.span_note(
span,
format!("...so type `{}` of expression is valid during the \
expression",
- self.ty_to_string(t))[]);
+ self.ty_to_string(t)).index(&FullRange));
}
infer::BindingTypeIsNotValidAtDecl(span) => {
self.tcx.sess.span_note(
span,
format!("...so that the reference type `{}` \
does not outlive the data it points at",
- self.ty_to_string(ty))[]);
+ self.ty_to_string(ty)).index(&FullRange));
}
infer::RelateParamBound(span, t) => {
self.tcx.sess.span_note(
span,
format!("...so that the type `{}` \
will meet the declared lifetime bounds",
- self.ty_to_string(t))[]);
+ self.ty_to_string(t)).index(&FullRange));
}
infer::RelateDefaultParamBound(span, t) => {
self.tcx.sess.span_note(
format!("...so that type parameter \
instantiated with `{}`, \
will meet its declared lifetime bounds",
- self.ty_to_string(t))[]);
+ self.ty_to_string(t)).index(&FullRange));
}
infer::RelateRegionParamBound(span) => {
self.tcx.sess.span_note(
span,
format!("...so that the declared lifetime parameter bounds \
- are satisfied")[]);
+ are satisfied").index(&FullRange));
}
}
}
Some(node) => match node {
ast_map::NodeItem(item) => match item.node {
ast::ItemFn(_, _, _, ref gen, _) => {
- taken.push_all(gen.lifetimes[]);
+ taken.push_all(gen.lifetimes.index(&FullRange));
None
},
_ => None
ast_map::NodeImplItem(ii) => {
match *ii {
ast::MethodImplItem(ref m) => {
- taken.push_all(m.pe_generics().lifetimes[]);
+ taken.push_all(m.pe_generics().lifetimes.index(&FullRange));
Some(m.id)
}
ast::TypeImplItem(_) => None,
let mut lifetime;
loop {
let mut s = String::from_str("'");
- s.push_str(num_to_string(self.counter.get())[]);
+ s.push_str(num_to_string(self.counter.get()).index(&FullRange));
if !self.taken.contains(&s) {
lifetime = name_to_dummy_lifetime(
- token::str_to_ident(s[]).name);
+ token::str_to_ident(s.index(&FullRange)).name);
self.generated.borrow_mut().push(lifetime);
break;
}
None => { }
}
- match self.freshen_map.entry(&key) {
+ match self.freshen_map.entry(key) {
Entry::Occupied(entry) => *entry.get(),
Entry::Vacant(entry) => {
let index = self.freshen_count;
// Regions that pre-dated the LUB computation stay as they are.
if !is_var_in_set(new_vars, r0) {
assert!(!r0.is_bound());
- debug!("generalize_region(r0={}): not new variable", r0);
+ debug!("generalize_region(r0={:?}): not new variable", r0);
return r0;
}
// *related* to regions that pre-date the LUB computation
// stay as they are.
if !tainted.iter().all(|r| is_var_in_set(new_vars, *r)) {
- debug!("generalize_region(r0={}): \
- non-new-variables found in {}",
+ debug!("generalize_region(r0={:?}): \
+ non-new-variables found in {:?}",
r0, tainted);
assert!(!r0.is_bound());
return r0;
// with.
for (a_br, a_r) in a_map.iter() {
if tainted.iter().any(|x| x == a_r) {
- debug!("generalize_region(r0={}): \
- replacing with {}, tainted={}",
+ debug!("generalize_region(r0={:?}): \
+ replacing with {:?}, tainted={:?}",
r0, *a_br, tainted);
return ty::ReLateBound(debruijn, *a_br);
}
infcx.tcx.sess.span_bug(
span,
- format!("region {} is not associated with \
+ format!("region {:?} is not associated with \
any bound region from A!",
- r0)[])
+ r0).index(&FullRange))
}
}
}
infcx.tcx.sess.span_bug(
span,
- format!("could not find original bound region for {}", r)[]);
+ format!("could not find original bound region for {:?}", r).index(&FullRange));
}
fn fresh_bound_variable(infcx: &InferCtxt, debruijn: ty::DebruijnIndex) -> ty::Region {
r => {
combiner.infcx().tcx.sess.span_bug(
combiner.trace().origin.span(),
- format!("found non-region-vid: {}", r)[]);
+ format!("found non-region-vid: {:?}", r).index(&FullRange));
}
}).collect()
}
err: Option<&ty::type_err<'tcx>>) where
M: FnOnce(Option<String>, String) -> String,
{
- debug!("hi! expected_ty = {}, actual_ty = {}", expected_ty, actual_ty);
+ debug!("hi! expected_ty = {:?}, actual_ty = {}", expected_ty, actual_ty);
let resolved_expected = expected_ty.map(|e_ty| self.resolve_type_vars_if_possible(&e_ty));
self.tcx.sess.span_err(sp, format!("{}{}",
mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty),
- error_str)[]);
+ error_str).index(&FullRange));
for err in err.iter() {
ty::note_and_explain_type_err(self.tcx, *err)
}
Reborrow(a) => format!("Reborrow({})", a.repr(tcx)),
ReborrowUpvar(a, b) => {
- format!("ReborrowUpvar({},{})", a.repr(tcx), b)
+ format!("ReborrowUpvar({},{:?})", a.repr(tcx), b)
}
ReferenceOutlivesReferent(_, a) => {
format!("ReferenceOutlivesReferent({})", a.repr(tcx))
format!("EarlyBoundRegion({},{})", a.repr(tcx), b.repr(tcx))
}
LateBoundRegion(a, b, c) => {
- format!("LateBoundRegion({},{},{})", a.repr(tcx), b.repr(tcx), c)
+ format!("LateBoundRegion({},{},{:?})", a.repr(tcx), b.repr(tcx), c)
}
BoundRegionInCoherence(a) => {
format!("bound_regionInCoherence({})", a.repr(tcx))
}
let requested_output = os::getenv("RUST_REGION_GRAPH");
- debug!("requested_output: {} requested_node: {}",
+ debug!("requested_output: {:?} requested_node: {:?}",
requested_output, requested_node);
let output_path = {
let mut node_ids = FnvHashMap::new();
{
let mut add_node = |&mut : node| {
- if let Vacant(e) = node_ids.entry(&node) {
+ if let Vacant(e) = node_ids.entry(node) {
e.insert(i);
i += 1;
}
fn node_label(&self, n: &Node) -> dot::LabelText {
match *n {
Node::RegionVid(n_vid) =>
- dot::LabelText::label(format!("{}", n_vid)),
+ dot::LabelText::label(format!("{:?}", n_vid)),
Node::Region(n_rgn) =>
dot::LabelText::label(format!("{}", n_rgn.repr(self.tcx))),
}
}
fn source(&self, edge: &Edge) -> Node {
let (n1, _) = constraint_to_nodes(edge);
- debug!("edge {} has source {}", edge, n1);
+ debug!("edge {:?} has source {:?}", edge, n1);
n1
}
fn target(&self, edge: &Edge) -> Node {
let (_, n2) = constraint_to_nodes(edge);
- debug!("edge {} has target {}", edge, n2);
+ debug!("edge {:?} has target {:?}", edge, n2);
n2
}
}
}
pub fn rollback_to(&self, snapshot: RegionSnapshot) {
- debug!("RegionVarBindings: rollback_to({})", snapshot);
+ debug!("RegionVarBindings: rollback_to({:?})", snapshot);
let mut undo_log = self.undo_log.borrow_mut();
assert!(undo_log.len() > snapshot.length);
assert!((*undo_log)[snapshot.length] == OpenSnapshot);
if self.in_snapshot() {
self.undo_log.borrow_mut().push(AddVar(vid));
}
- debug!("created new region variable {} with origin {}",
+ debug!("created new region variable {:?} with origin {}",
vid, origin.repr(self.tcx));
return vid;
}
let mut givens = self.givens.borrow_mut();
if givens.insert((sub, sup)) {
- debug!("add_given({} <= {})",
+ debug!("add_given({} <= {:?})",
sub.repr(self.tcx),
sup);
origin.span(),
format!("cannot relate bound region: {} <= {}",
sub.repr(self.tcx),
- sup.repr(self.tcx))[]);
+ sup.repr(self.tcx)).index(&FullRange));
}
(_, ReStatic) => {
// all regions are subregions of static, so we can ignore this
}
Some(ref values) => {
let r = lookup(values, rid);
- debug!("resolve_var({}) = {}", rid, r.repr(self.tcx));
+ debug!("resolve_var({:?}) = {}", rid, r.repr(self.tcx));
r
}
}
}
relate(self, a, ReInfer(ReVar(c)));
relate(self, b, ReInfer(ReVar(c)));
- debug!("combine_vars() c={}", c);
+ debug!("combine_vars() c={:?}", c);
ReInfer(ReVar(c))
}
/// made---`r0` itself will be the first entry. This is used when checking whether skolemized
/// regions are being improperly related to other regions.
pub fn tainted(&self, mark: &RegionSnapshot, r0: Region) -> Vec<Region> {
- debug!("tainted(mark={}, r0={})", mark, r0.repr(self.tcx));
+ debug!("tainted(mark={:?}, r0={})", mark, r0.repr(self.tcx));
let _indenter = indenter();
// `result_set` acts as a worklist: we explore all outgoing
while result_index < result_set.len() {
// nb: can't use uint::range() here because result_set grows
let r = result_set[result_index];
- debug!("result_index={}, r={}", result_index, r);
+ debug!("result_index={}, r={:?}", result_index, r);
for undo_entry in
self.undo_log.borrow().slice_from(mark.length).iter()
self.tcx.sess.bug(
format!("cannot relate bound region: LUB({}, {})",
a.repr(self.tcx),
- b.repr(self.tcx))[]);
+ b.repr(self.tcx)).index(&FullRange));
}
(ReStatic, _) | (_, ReStatic) => {
self.tcx.sess.span_bug(
(*self.var_origins.borrow())[v_id.index as uint].span(),
format!("lub_concrete_regions invoked with \
- non-concrete regions: {}, {}",
+ non-concrete regions: {:?}, {:?}",
a,
- b)[]);
+ b).index(&FullRange));
}
(ReFree(ref fr), ReScope(s_id)) |
a: Region,
b: Region)
-> cres<'tcx, Region> {
- debug!("glb_concrete_regions({}, {})", a, b);
+ debug!("glb_concrete_regions({:?}, {:?})", a, b);
match (a, b) {
(ReLateBound(..), _) |
(_, ReLateBound(..)) |
self.tcx.sess.bug(
format!("cannot relate bound region: GLB({}, {})",
a.repr(self.tcx),
- b.repr(self.tcx))[]);
+ b.repr(self.tcx)).index(&FullRange));
}
(ReStatic, r) | (r, ReStatic) => {
self.tcx.sess.span_bug(
(*self.var_origins.borrow())[v_id.index as uint].span(),
format!("glb_concrete_regions invoked with \
- non-concrete regions: {}, {}",
+ non-concrete regions: {:?}, {:?}",
a,
- b)[]);
+ b).index(&FullRange));
}
(ReFree(ref fr), ReScope(s_id)) |
// scopes or two free regions. So, if one of
// these scopes is a subscope of the other, return
// it. Otherwise fail.
- debug!("intersect_scopes(scope_a={}, scope_b={}, region_a={}, region_b={})",
+ debug!("intersect_scopes(scope_a={:?}, scope_b={:?}, region_a={:?}, region_b={:?})",
scope_a, scope_b, region_a, region_b);
match self.tcx.region_maps.nearest_common_ancestor(scope_a, scope_b) {
Some(r_id) if scope_a == r_id => Ok(ReScope(scope_b)),
// Dorky hack to cause `dump_constraints` to only get called
// if debug mode is enabled:
- debug!("----() End constraint listing {}---", self.dump_constraints());
+ debug!("----() End constraint listing {:?}---", self.dump_constraints());
graphviz::maybe_print_constraints_for(self, subject);
self.expansion(var_data.as_mut_slice());
self.contraction(var_data.as_mut_slice());
let values =
- self.extract_values_and_collect_conflicts(var_data[],
+ self.extract_values_and_collect_conflicts(var_data.index(&FullRange),
errors);
self.collect_concrete_region_errors(&values, errors);
values
b_data: &mut VarData)
-> bool
{
- debug!("expand_node({}, {} == {})",
+ debug!("expand_node({}, {:?} == {})",
a_region.repr(self.tcx),
b_vid,
b_data.value.repr(self.tcx));
b_data.classification = Expanding;
match b_data.value {
NoValue => {
- debug!("Setting initial value of {} to {}",
+ debug!("Setting initial value of {:?} to {}",
b_vid, a_region.repr(self.tcx));
b_data.value = Value(a_region);
return false;
}
- debug!("Expanding value of {} from {} to {}",
+ debug!("Expanding value of {:?} from {} to {}",
b_vid,
cur_region.repr(self.tcx),
lub.repr(self.tcx));
a_data: &mut VarData,
b_region: Region)
-> bool {
- debug!("contract_node({} == {}/{}, {})",
+ debug!("contract_node({:?} == {}/{:?}, {})",
a_vid, a_data.value.repr(self.tcx),
a_data.classification, b_region.repr(self.tcx));
b_region: Region)
-> bool {
if !this.is_subregion_of(a_region, b_region) {
- debug!("Setting {} to ErrorValue: {} not subregion of {}",
+ debug!("Setting {:?} to ErrorValue: {} not subregion of {}",
a_vid,
a_region.repr(this.tcx),
b_region.repr(this.tcx));
if glb == a_region {
false
} else {
- debug!("Contracting value of {} from {} to {}",
+ debug!("Contracting value of {:?} from {} to {}",
a_vid,
a_region.repr(this.tcx),
glb.repr(this.tcx));
}
}
Err(_) => {
- debug!("Setting {} to ErrorValue: no glb of {}, {}",
+ debug!("Setting {:?} to ErrorValue: no glb of {}, {}",
a_vid,
a_region.repr(this.tcx),
b_region.repr(this.tcx));
self.tcx.sess.span_bug(
(*self.var_origins.borrow())[node_idx.index as uint].span(),
format!("collect_error_for_expanding_node() could not find error \
- for var {}, lower_bounds={}, upper_bounds={}",
+ for var {:?}, lower_bounds={}, upper_bounds={}",
node_idx,
lower_bounds.repr(self.tcx),
- upper_bounds.repr(self.tcx))[]);
+ upper_bounds.repr(self.tcx)).index(&FullRange));
}
fn collect_error_for_contracting_node(
self.tcx.sess.span_bug(
(*self.var_origins.borrow())[node_idx.index as uint].span(),
format!("collect_error_for_contracting_node() could not find error \
- for var {}, upper_bounds={}",
+ for var {:?}, upper_bounds={}",
node_idx,
- upper_bounds.repr(self.tcx))[]);
+ upper_bounds.repr(self.tcx)).index(&FullRange));
}
fn collect_concrete_regions(&self,
state.dup_found = true;
}
- debug!("collect_concrete_regions(orig_node_idx={}, node_idx={}, \
- classification={})",
+ debug!("collect_concrete_regions(orig_node_idx={:?}, node_idx={:?}, \
+ classification={:?})",
orig_node_idx, node_idx, classification);
// figure out the direction from which this node takes its
graph: &RegionGraph,
source_vid: RegionVid,
dir: Direction) {
- debug!("process_edges(source_vid={}, dir={})", source_vid, dir);
+ debug!("process_edges(source_vid={:?}, dir={:?})", source_vid, dir);
let source_node_index = NodeIndex(source_vid.index as uint);
graph.each_adjacent_edge(source_node_index, dir, |_, edge| {
ty::ty_infer(_) => {
self.infcx.tcx.sess.bug(
format!("Unexpected type in full type resolver: {}",
- t.repr(self.infcx.tcx))[]);
+ t.repr(self.infcx.tcx)).index(&FullRange));
}
_ => {
ty_fold::super_fold_ty(self, t)
let escaping_type = self.probe(vid).unwrap();
escaping_types.push(escaping_type);
}
- debug!("SpecifyVar({}) new_elem_threshold={}", vid, new_elem_threshold);
+ debug!("SpecifyVar({:?}) new_elem_threshold={}", vid, new_elem_threshold);
}
_ => { }
pub use self::VarValue::*;
-use std::kinds::marker;
+use std::marker;
use middle::ty::{expected_found, IntVarValue};
use middle::ty::{self, Ty};
pub fn new_key(&mut self, value: V) -> K {
let index = self.values.push(Root(value, 0));
let k = UnifyKey::from_index(index);
- debug!("{}: created new key: {}",
+ debug!("{}: created new key: {:?}",
UnifyKey::tag(None::<K>),
k);
k
debug!("with_each_combination(substs={})",
substs.repr(self.tcx));
- callback.call_mut((substs,));
+ callback(substs);
}
Some((space, index, ¶m_ty)) => {
- debug!("with_each_combination: space={}, index={}, param_ty={}",
+ debug!("with_each_combination: space={:?}, index={}, param_ty={}",
space, index, param_ty.repr(self.tcx));
if !ty::type_is_sized(param_env, span, param_ty) {
ShrTraitLangItem, "shr", shr_trait;
IndexTraitLangItem, "index", index_trait;
IndexMutTraitLangItem, "index_mut", index_mut_trait;
- SliceTraitLangItem, "slice", slice_trait;
- SliceMutTraitLangItem, "slice_mut", slice_mut_trait;
RangeStructLangItem, "range", range_struct;
RangeFromStructLangItem, "range_from", range_from_struct;
RangeToStructLangItem, "range_to", range_to_struct;
use middle::def::*;
use middle::mem_categorization::Typer;
use middle::pat_util;
+use middle::region::CodeExtent;
use middle::ty;
use middle::ty::UnboxedClosureTyper;
use lint;
self.lnks.push(lnk);
self.num_live_nodes += 1;
- debug!("{} is of kind {}", ln.to_string(),
+ debug!("{:?} is of kind {}", ln,
live_node_kind_to_string(lnk, self.tcx));
ln
let ln = self.add_live_node(lnk);
self.live_node_map.insert(node_id, ln);
- debug!("{} is node {}", ln.to_string(), node_id);
+ debug!("{:?} is node {}", ln, node_id);
}
fn add_variable(&mut self, vk: VarKind) -> Variable {
ImplicitRet | CleanExit => {}
}
- debug!("{} is {}", v.to_string(), vk);
+ debug!("{:?} is {:?}", v, vk);
v
}
self.tcx
.sess
.span_bug(span, format!("no variable registered for id {}",
- node_id)[]);
+ node_id).index(&FullRange));
}
}
}
// swap in a new set of IR maps for this function body:
let mut fn_maps = IrMaps::new(ir.tcx);
- debug!("creating fn_maps: {}", &fn_maps as *const IrMaps);
+ debug!("creating fn_maps: {:?}", &fn_maps as *const IrMaps);
for arg in decl.inputs.iter() {
pat_util::pat_bindings(&ir.tcx.def_map,
fn visit_arm(ir: &mut IrMaps, arm: &ast::Arm) {
for pat in arm.pats.iter() {
pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| {
- debug!("adding local variable {} from match with bm {}",
+ debug!("adding local variable {} from match with bm {:?}",
p_id, bm);
let name = path1.node;
ir.add_live_node_for_node(p_id, VarDefNode(sp));
// live nodes required for uses or definitions of variables:
ast::ExprPath(_) => {
let def = ir.tcx.def_map.borrow()[expr.id].clone();
- debug!("expr {}: path that leads to {}", expr.id, def);
+ debug!("expr {}: path that leads to {:?}", expr.id, def);
if let DefLocal(..) = def {
ir.add_live_node_for_node(expr.id, ExprNode(expr.span));
}
}
ast::ExprForLoop(ref pat, _, _, _) => {
pat_util::pat_bindings(&ir.tcx.def_map, &**pat, |bm, p_id, sp, path1| {
- debug!("adding local variable {} from for loop with bm {}",
+ debug!("adding local variable {} from for loop with bm {:?}",
p_id, bm);
let name = path1.node;
ir.add_live_node_for_node(p_id, VarDefNode(sp));
self.ir.tcx.sess.span_bug(
span,
format!("no live node registered for node {}",
- node_id)[]);
+ node_id).index(&FullRange));
}
}
}
for var_idx in range(0u, self.ir.num_vars) {
let idx = node_base_idx + var_idx;
if test(idx).is_valid() {
- try!(write!(wr, " {}", Variable(var_idx).to_string()));
+ try!(write!(wr, " {:?}", Variable(var_idx)));
}
}
Ok(())
let mut wr = Vec::new();
{
let wr = &mut wr as &mut io::Writer;
- write!(wr, "[ln({}) of kind {} reads", ln.get(), self.ir.lnk(ln));
+ write!(wr, "[ln({:?}) of kind {:?} reads", ln.get(), self.ir.lnk(ln));
self.write_vars(wr, ln, |idx| self.users[idx].reader);
write!(wr, " writes");
self.write_vars(wr, ln, |idx| self.users[idx].writer);
- write!(wr, " precedes {}]", self.successors[ln.get()].to_string());
+ write!(wr, " precedes {:?}]", self.successors[ln.get()]);
}
String::from_utf8(wr).unwrap()
}
}
});
- debug!("merge_from_succ(ln={}, succ={}, first_merge={}, changed={})",
- ln.to_string(), self.ln_str(succ_ln), first_merge, changed);
+ debug!("merge_from_succ(ln={:?}, succ={}, first_merge={}, changed={})",
+ ln, self.ln_str(succ_ln), first_merge, changed);
return changed;
fn copy_if_invalid(src: LiveNode, dst: &mut LiveNode) -> bool {
self.users[idx].reader = invalid_node();
self.users[idx].writer = invalid_node();
- debug!("{} defines {} (idx={}): {}", writer.to_string(), var.to_string(),
+ debug!("{:?} defines {:?} (idx={}): {}", writer, var,
idx, self.ln_str(writer));
}
// Either read, write, or both depending on the acc bitset
fn acc(&mut self, ln: LiveNode, var: Variable, acc: uint) {
- debug!("{} accesses[{:x}] {}: {}",
- ln.to_string(), acc, var.to_string(), self.ln_str(ln));
+ debug!("{:?} accesses[{:x}] {:?}: {}",
+ ln, acc, var, self.ln_str(ln));
let idx = self.idx(ln, var);
let user = &mut self.users[idx];
|this| this.propagate_through_fn_block(decl, body));
// hack to skip the loop unless debug! is enabled:
- debug!("^^ liveness computation results for body {} (entry={})",
+ debug!("^^ liveness computation results for body {} (entry={:?})",
{
for ln_idx in range(0u, self.ir.num_live_nodes) {
- debug!("{}", self.ln_str(LiveNode(ln_idx)));
+ debug!("{:?}", self.ln_str(LiveNode(ln_idx)));
}
body.id
},
- entry_ln.to_string());
+ entry_ln);
entry_ln
}
// Uninteresting cases: just propagate in rev exec order
ast::ExprVec(ref exprs) => {
- self.propagate_through_exprs(exprs[], succ)
+ self.propagate_through_exprs(exprs.index(&FullRange), succ)
}
ast::ExprRepeat(ref element, ref count) => {
ast::ExprCall(ref f, ref args) => {
let diverges = !self.ir.tcx.is_method_call(expr.id) && {
- let t_ret = ty::ty_fn_ret(ty::expr_ty_adjusted(self.ir.tcx, &**f));
- t_ret == ty::FnDiverging
+ ty::ty_fn_ret(ty::expr_ty_adjusted(self.ir.tcx, &**f)).diverges()
};
let succ = if diverges {
self.s.exit_ln
} else {
succ
};
- let succ = self.propagate_through_exprs(args[], succ);
+ let succ = self.propagate_through_exprs(args.index(&FullRange), succ);
self.propagate_through_expr(&**f, succ)
}
ast::ExprMethodCall(_, _, ref args) => {
let method_call = ty::MethodCall::expr(expr.id);
let method_ty = self.ir.tcx.method_map.borrow().get(&method_call).unwrap().ty;
- let diverges = ty::ty_fn_ret(method_ty) == ty::FnDiverging;
+ let diverges = ty::ty_fn_ret(method_ty).diverges();
let succ = if diverges {
self.s.exit_ln
} else {
succ
};
- self.propagate_through_exprs(args[], succ)
+ self.propagate_through_exprs(args.index(&FullRange), succ)
}
ast::ExprTup(ref exprs) => {
- self.propagate_through_exprs(exprs[], succ)
+ self.propagate_through_exprs(exprs.index(&FullRange), succ)
}
ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => {
}
impl<'a, 'tcx> Liveness<'a, 'tcx> {
- fn fn_ret(&self, id: NodeId) -> ty::FnOutput<'tcx> {
+ fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> {
let fn_ty = ty::node_id_to_type(self.ir.tcx, id);
match fn_ty.sty {
ty::ty_unboxed_closure(closure_def_id, _, substs) =>
- self.ir.tcx.unboxed_closure_type(closure_def_id, substs).sig.0.output,
+ self.ir.tcx.unboxed_closure_type(closure_def_id, substs).sig.output(),
_ =>
ty::ty_fn_ret(fn_ty),
}
sp: Span,
_fk: FnKind,
entry_ln: LiveNode,
- body: &ast::Block) {
- match self.fn_ret(id) {
+ body: &ast::Block)
+ {
+ // within the fn body, late-bound regions are liberated:
+ let fn_ret =
+ ty::liberate_late_bound_regions(
+ self.ir.tcx,
+ CodeExtent::from_node_id(body.id),
+ &self.fn_ret(id));
+
+ match fn_ret {
ty::FnConverging(t_ret)
if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() => {
Ok(self.cat_tup_field(expr, base_cmt, idx.node, expr_ty))
}
- ast::ExprIndex(ref base, ref idx) => {
- match idx.node {
- ast::ExprRange(..) => {
- // Slicing syntax special case (KILLME).
- Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
+ ast::ExprIndex(ref base, _) => {
+ let method_call = ty::MethodCall::expr(expr.id());
+ match self.typer.node_method_ty(method_call) {
+ Some(method_ty) => {
+ // If this is an index implemented by a method call, then it
+ // will include an implicit deref of the result.
+ let ret_ty = self.overloaded_method_return_ty(method_ty);
+ self.cat_deref(expr,
+ self.cat_rvalue_node(expr.id(),
+ expr.span(),
+ ret_ty), 1, true)
}
- _ => {
- let method_call = ty::MethodCall::expr(expr.id());
- match self.typer.node_method_ty(method_call) {
- Some(method_ty) => {
- // If this is an index implemented by a method call, then it will
- // include an implicit deref of the result.
- let ret_ty = ty::ty_fn_ret(method_ty).unwrap();
- self.cat_deref(expr,
- self.cat_rvalue_node(expr.id(),
- expr.span(),
- ret_ty), 1, true)
- }
- None => {
- self.cat_index(expr, try!(self.cat_expr(&**base)))
- }
- }
+ None => {
+ self.cat_index(expr, try!(self.cat_expr(&**base)))
}
}
}
expr_ty: Ty<'tcx>,
def: def::Def)
-> McResult<cmt<'tcx>> {
- debug!("cat_def: id={} expr={} def={}",
+ debug!("cat_def: id={} expr={} def={:?}",
id, expr_ty.repr(self.tcx()), def);
match def {
span,
format!("Upvar of non-closure {} - {}",
fn_node_id,
- ty.repr(self.tcx()))[]);
+ ty.repr(self.tcx())).index(&FullRange));
}
}
}
};
let method_ty = self.typer.node_method_ty(method_call);
- debug!("cat_deref: method_call={} method_ty={}",
+ debug!("cat_deref: method_call={:?} method_ty={:?}",
method_call, method_ty.map(|ty| ty.repr(self.tcx())));
let base_cmt = match method_ty {
Some(method_ty) => {
- let ref_ty = ty::ty_fn_ret(method_ty).unwrap();
+ let ref_ty =
+ ty::assert_no_late_bound_regions(
+ self.tcx(), &ty::ty_fn_ret(method_ty)).unwrap();
self.cat_rvalue_node(node.id(), node.span(), ref_ty)
}
None => base_cmt
let element_ty = match method_ty {
Some(method_ty) => {
- let ref_ty = ty::ty_fn_ret(method_ty).unwrap();
+ let ref_ty = self.overloaded_method_return_ty(method_ty);
base_cmt = self.cat_rvalue_node(elt.id(), elt.span(), ref_ty);
- ty::ty_fn_args(method_ty)[0]
+
+ // FIXME(#20649) -- why are we using the `self_ty` as the element type...?
+ let self_ty = ty::ty_fn_sig(method_ty).input(0);
+ ty::assert_no_late_bound_regions(self.tcx(), &self_ty)
}
None => {
match ty::array_element_ty(self.tcx(), base_cmt.ty) {
Ok(())
}
+
+ fn overloaded_method_return_ty(&self,
+ method_ty: Ty<'tcx>)
+ -> Ty<'tcx>
+ {
+ // When we process an overloaded `*` or `[]` etc, we often
+ // need to extract the return type of the method. These method
+ // types are generated by method resolution and always have
+ // all late-bound regions fully instantiated, so we just want
+ // to skip past the binder.
+ ty::assert_no_late_bound_regions(self.tcx(), &ty::ty_fn_ret(method_ty))
+ .unwrap() // overloaded ops do not diverge, either
+ }
}
#[derive(Copy)]
impl<'tcx> Repr<'tcx> for cmt_<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
- format!("{{{} id:{} m:{} ty:{}}}",
+ format!("{{{} id:{} m:{:?} ty:{}}}",
self.cat.repr(tcx),
self.id,
self.mutbl,
cat_rvalue(..) |
cat_local(..) |
cat_upvar(..) => {
- format!("{}", *self)
+ format!("{:?}", *self)
}
cat_deref(ref cmt, derefs, ptr) => {
format!("{}-{}{}->", cmt.cat.repr(tcx), ptr_sigil(ptr), derefs)
fn def_privacy(&self, did: ast::DefId) -> PrivacyResult {
if !is_local(did) {
if self.external_exports.contains(&did) {
- debug!("privacy - {} was externally exported", did);
+ debug!("privacy - {:?} was externally exported", did);
return Allowable;
}
- debug!("privacy - is {} a public method", did);
+ debug!("privacy - is {:?} a public method", did);
return match self.tcx.impl_or_trait_items.borrow().get(&did) {
Some(&ty::MethodTraitItem(ref meth)) => {
- debug!("privacy - well at least it's a method: {}",
+ debug!("privacy - well at least it's a method: {:?}",
*meth);
match meth.container {
ty::TraitContainer(id) => {
- debug!("privacy - recursing on trait {}", id);
+ debug!("privacy - recursing on trait {:?}", id);
self.def_privacy(id)
}
ty::ImplContainer(id) => {
match ty::impl_trait_ref(self.tcx, id) {
Some(t) => {
- debug!("privacy - impl of trait {}", id);
+ debug!("privacy - impl of trait {:?}", id);
self.def_privacy(t.def_id)
}
None => {
- debug!("privacy - found a method {}",
+ debug!("privacy - found a method {:?}",
meth.vis);
if meth.vis == ast::Public {
Allowable
Some(&ty::TypeTraitItem(ref typedef)) => {
match typedef.container {
ty::TraitContainer(id) => {
- debug!("privacy - recursing on trait {}", id);
+ debug!("privacy - recursing on trait {:?}", id);
self.def_privacy(id)
}
ty::ImplContainer(id) => {
match ty::impl_trait_ref(self.tcx, id) {
Some(t) => {
- debug!("privacy - impl of trait {}", id);
+ debug!("privacy - impl of trait {:?}", id);
self.def_privacy(t.def_id)
}
None => {
- debug!("privacy - found a typedef {}",
+ debug!("privacy - found a typedef {:?}",
typedef.vis);
if typedef.vis == ast::Public {
Allowable
match result {
None => true,
Some((span, msg, note)) => {
- self.tcx.sess.span_err(span, msg[]);
+ self.tcx.sess.span_err(span, msg.index(&FullRange));
match note {
Some((span, msg)) => {
- self.tcx.sess.span_note(span, msg[])
+ self.tcx.sess.span_note(span, msg.index(&FullRange))
}
None => {},
}
let fields = ty::lookup_struct_fields(self.tcx, id);
let field = match name {
NamedField(ident) => {
- debug!("privacy - check named field {} in struct {}", ident.name, id);
+ debug!("privacy - check named field {} in struct {:?}", ident.name, id);
fields.iter().find(|f| f.name == ident.name).unwrap()
}
UnnamedField(idx) => &fields[idx]
UnnamedField(idx) => format!("field #{} of {} is private",
idx + 1, struct_desc),
};
- self.tcx.sess.span_err(span, msg[]);
+ self.tcx.sess.span_err(span, msg.index(&FullRange));
}
// Given the ID of a method, checks to ensure it's in scope.
method_id,
None,
format!("method `{}`",
- string)[]));
+ string).index(&FullRange)));
}
// Checks that a path is in scope.
self.ensure_public(span,
def,
Some(origdid),
- format!("{} `{}`", tyname, name)[])
+ format!("{} `{}`", tyname, name).index(&FullRange))
};
match self.last_private_map[path_id] {
// monomorphized or it was marked with `#[inline]`. This will only return
// true for functions.
fn item_might_be_inlined(item: &ast::Item) -> bool {
- if attributes_specify_inlining(item.attrs[]) {
+ if attributes_specify_inlining(item.attrs.index(&FullRange)) {
return true
}
fn method_might_be_inlined(tcx: &ty::ctxt, method: &ast::Method,
impl_src: ast::DefId) -> bool {
- if attributes_specify_inlining(method.attrs[]) ||
+ if attributes_specify_inlining(method.attrs.index(&FullRange)) ||
generics_require_inlining(method.pe_generics()) {
return true
}
ast::MethodImplItem(ref method) => {
if generics_require_inlining(method.pe_generics()) ||
attributes_specify_inlining(
- method.attrs[]) {
+ method.attrs.index(&FullRange)) {
true
} else {
let impl_did = self.tcx
None => {
self.tcx.sess.bug(format!("found unmapped ID in worklist: \
{}",
- search_item)[])
+ search_item).index(&FullRange))
}
}
}
.bug(format!("found unexpected thingy in worklist: {}",
self.tcx
.map
- .node_to_string(search_item))[])
+ .node_to_string(search_item)).index(&FullRange))
}
}
}
None => {}
}
- debug!("relate_free_regions(sub={}, sup={})", sub, sup);
+ debug!("relate_free_regions(sub={:?}, sup={:?})", sub, sup);
self.free_region_map.borrow_mut().insert(sub, vec!(sup));
}
pub fn record_encl_scope(&self, sub: CodeExtent, sup: CodeExtent) {
- debug!("record_encl_scope(sub={}, sup={})", sub, sup);
+ debug!("record_encl_scope(sub={:?}, sup={:?})", sub, sup);
assert!(sub != sup);
self.scope_map.borrow_mut().insert(sub, sup);
}
pub fn record_var_scope(&self, var: ast::NodeId, lifetime: CodeExtent) {
- debug!("record_var_scope(sub={}, sup={})", var, lifetime);
+ debug!("record_var_scope(sub={:?}, sup={:?})", var, lifetime);
assert!(var != lifetime.node_id());
self.var_map.borrow_mut().insert(var, lifetime);
}
pub fn record_rvalue_scope(&self, var: ast::NodeId, lifetime: CodeExtent) {
- debug!("record_rvalue_scope(sub={}, sup={})", var, lifetime);
+ debug!("record_rvalue_scope(sub={:?}, sup={:?})", var, lifetime);
assert!(var != lifetime.node_id());
self.rvalue_scopes.borrow_mut().insert(var, lifetime);
}
/// e.g. by an expression like `a().f` -- they will be freed within the innermost terminating
/// scope.
pub fn mark_as_terminating_scope(&self, scope_id: CodeExtent) {
- debug!("record_terminating_scope(scope_id={})", scope_id);
+ debug!("record_terminating_scope(scope_id={:?})", scope_id);
self.terminating_scopes.borrow_mut().insert(scope_id);
}
//! Returns the narrowest scope that encloses `id`, if any.
match self.scope_map.borrow().get(&id) {
Some(&r) => r,
- None => { panic!("no enclosing scope for id {}", id); }
+ None => { panic!("no enclosing scope for id {:?}", id); }
}
}
pub fn var_scope(&self, var_id: ast::NodeId) -> CodeExtent {
match self.var_map.borrow().get(&var_id) {
Some(&r) => r,
- None => { panic!("no enclosing scope for id {}", var_id); }
+ None => { panic!("no enclosing scope for id {:?}", var_id); }
}
}
// check for a designated rvalue scope
match self.rvalue_scopes.borrow().get(&expr_id) {
Some(&s) => {
- debug!("temporary_scope({}) = {} [custom]", expr_id, s);
+ debug!("temporary_scope({:?}) = {:?} [custom]", expr_id, s);
return Some(s);
}
None => { }
id = p;
}
None => {
- debug!("temporary_scope({}) = None", expr_id);
+ debug!("temporary_scope({:?}) = None", expr_id);
return None;
}
}
}
- debug!("temporary_scope({}) = {} [enclosing]", expr_id, id);
+ debug!("temporary_scope({:?}) = {:?} [enclosing]", expr_id, id);
return Some(id);
}
//! Returns the lifetime of the variable `id`.
let scope = ty::ReScope(self.var_scope(id));
- debug!("var_region({}) = {}", id, scope);
+ debug!("var_region({:?}) = {:?}", id, scope);
scope
}
while superscope != s {
match self.scope_map.borrow().get(&s) {
None => {
- debug!("is_subscope_of({}, {}, s={})=false",
+ debug!("is_subscope_of({:?}, {:?}, s={:?})=false",
subscope, superscope, s);
return false;
}
}
- debug!("is_subscope_of({}, {})=true",
+ debug!("is_subscope_of({:?}, {:?})=true",
subscope, superscope);
return true;
sub_region: ty::Region,
super_region: ty::Region)
-> bool {
- debug!("is_subregion_of(sub_region={}, super_region={})",
+ debug!("is_subregion_of(sub_region={:?}, super_region={:?})",
sub_region, super_region);
sub_region == super_region || {
fn ancestors_of(this: &RegionMaps, scope: CodeExtent)
-> Vec<CodeExtent> {
- // debug!("ancestors_of(scope={})", scope);
+ // debug!("ancestors_of(scope={:?})", scope);
let mut result = vec!(scope);
let mut scope = scope;
loop {
scope = superscope;
}
}
- // debug!("ancestors_of_loop(scope={})", scope);
+ // debug!("ancestors_of_loop(scope={:?})", scope);
}
}
}
}
fn resolve_block(visitor: &mut RegionResolutionVisitor, blk: &ast::Block) {
- debug!("resolve_block(blk.id={})", blk.id);
+ debug!("resolve_block(blk.id={:?})", blk.id);
// Record the parent of this block.
record_superlifetime(visitor, blk.id, blk.span);
fn resolve_stmt(visitor: &mut RegionResolutionVisitor, stmt: &ast::Stmt) {
let stmt_id = stmt_id(stmt);
- debug!("resolve_stmt(stmt.id={})", stmt_id);
+ debug!("resolve_stmt(stmt.id={:?})", stmt_id);
let stmt_scope = CodeExtent::from_node_id(stmt_id);
visitor.region_maps.mark_as_terminating_scope(stmt_scope);
}
fn resolve_expr(visitor: &mut RegionResolutionVisitor, expr: &ast::Expr) {
- debug!("resolve_expr(expr.id={})", expr.id);
+ debug!("resolve_expr(expr.id={:?})", expr.id);
record_superlifetime(visitor, expr.id, expr.span);
}
fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) {
- debug!("resolve_local(local.id={},local.init={})",
+ debug!("resolve_local(local.id={:?},local.init={:?})",
local.id,local.init.is_some());
let blk_id = match visitor.cx.var_parent {
// A, but the inner rvalues `a()` and `b()` have an extended lifetime
// due to rule C.
//
- // FIXME(#6308) -- Note that `[]` patterns work more smoothly post-DST.
+ // FIXME(#6308) -- Note that `.index(&FullRange)` patterns work more smoothly post-DST.
match local.init {
Some(ref expr) => {
body: &ast::Block,
sp: Span,
id: ast::NodeId) {
- debug!("region::resolve_fn(id={}, \
- span={}, \
- body.id={}, \
- cx.parent={})",
+ debug!("region::resolve_fn(id={:?}, \
+ span={:?}, \
+ body.id={:?}, \
+ cx.parent={:?})",
id,
visitor.sess.codemap().span_to_string(sp),
body.id,
fn visit_poly_trait_ref(&mut self, trait_ref:
&ast::PolyTraitRef,
_modifier: &ast::TraitBoundModifier) {
- debug!("visit_poly_trait_ref trait_ref={}", trait_ref);
+ debug!("visit_poly_trait_ref trait_ref={:?}", trait_ref);
self.with(LateScope(&trait_ref.bound_lifetimes, self.scope), |old_scope, this| {
this.check_lifetime_defs(old_scope, &trait_ref.bound_lifetimes);
scope: &wrap_scope,
def_map: self.def_map,
};
- debug!("entering scope {}", this.scope);
+ debug!("entering scope {:?}", this.scope);
f(self.scope, &mut this);
- debug!("exiting scope {}", this.scope);
+ debug!("exiting scope {:?}", this.scope);
}
/// Visits self by adding a scope and handling recursive walk over the contents with `walk`.
{
let referenced_idents = early_bound_lifetime_names(generics);
- debug!("visit_early_late: referenced_idents={}",
+ debug!("visit_early_late: referenced_idents={:?}",
referenced_idents);
let (early, late): (Vec<_>, _) = generics.lifetimes.iter().cloned().partition(
self.sess.span_err(
lifetime_ref.span,
format!("use of undeclared lifetime name `{}`",
- token::get_name(lifetime_ref.name))[]);
+ token::get_name(lifetime_ref.name)).index(&FullRange));
}
fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &Vec<ast::LifetimeDef>) {
lifetime.lifetime.span,
format!("illegal lifetime parameter name: `{}`",
token::get_name(lifetime.lifetime.name))
- []);
+ .index(&FullRange));
}
}
format!("lifetime name `{}` declared twice in \
the same scope",
token::get_name(lifetime_j.lifetime.name))
- []);
+ .index(&FullRange));
}
}
probably a bug in syntax::fold");
}
- debug!("lifetime_ref={} id={} resolved to {}",
+ debug!("lifetime_ref={:?} id={:?} resolved to {:?}",
lifetime_to_string(lifetime_ref),
lifetime_ref.id,
def);
impl<'a> fmt::Show for ScopeChain<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
- EarlyScope(space, defs, _) => write!(fmt, "EarlyScope({}, {})", space, defs),
- LateScope(defs, _) => write!(fmt, "LateScope({})", defs),
- BlockScope(id, _) => write!(fmt, "BlockScope({})", id),
+ EarlyScope(space, defs, _) => write!(fmt, "EarlyScope({:?}, {:?})", space, defs),
+ LateScope(defs, _) => write!(fmt, "LateScope({:?})", defs),
+ BlockScope(id, _) => write!(fmt, "BlockScope({:?})", id),
RootScope => write!(fmt, "RootScope"),
}
}
// is this definition the implementation of a trait method?
match ty::trait_item_of_item(tcx, id) {
Some(ty::MethodTraitItemId(trait_method_id)) if trait_method_id != id => {
- debug!("lookup: trait_method_id={}", trait_method_id);
+ debug!("lookup: trait_method_id={:?}", trait_method_id);
return lookup(tcx, trait_method_id)
}
_ => {}
// stability of the trait to determine the stability of any
// unmarked impls for it. See FIXME above for more details.
- debug!("lookup: trait_id={}", trait_id);
+ debug!("lookup: trait_id={:?}", trait_id);
lookup(tcx, trait_id)
} else {
None
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
try!(write!(fmt, "VecPerParamSpace {{"));
for space in ParamSpace::all().iter() {
- try!(write!(fmt, "{}: {}, ", *space, self.get_slice(*space)));
+ try!(write!(fmt, "{:?}: {:?}, ", *space, self.get_slice(*space)));
}
try!(write!(fmt, "}}"));
Ok(())
span,
format!("Type parameter out of range \
when substituting in region {} (root type={}) \
- (space={}, index={})",
+ (space={:?}, index={})",
region_name.as_str(),
self.root_ty.repr(self.tcx()),
- space, i)[]);
+ space, i).index(&FullRange));
}
}
}
let span = self.span.unwrap_or(DUMMY_SP);
self.tcx().sess.span_bug(
span,
- format!("Type parameter `{}` ({}/{}/{}) out of range \
+ format!("Type parameter `{}` ({}/{:?}/{}) out of range \
when substituting (root type={}) substs={}",
p.repr(self.tcx()),
source_ty.repr(self.tcx()),
p.space,
p.idx,
self.root_ty.repr(self.tcx()),
- self.substs.repr(self.tcx()))[]);
+ self.substs.repr(self.tcx())).index(&FullRange));
}
};
/// first case we do not increase the Debruijn index and in the second case we do. The reason
/// is that only in the second case have we passed through a fn binder.
fn shift_regions_through_binders(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
- debug!("shift_regions(ty={}, region_binders_passed={}, type_has_escaping_regions={})",
+ debug!("shift_regions(ty={:?}, region_binders_passed={:?}, type_has_escaping_regions={:?})",
ty.repr(self.tcx()), self.region_binders_passed, ty::type_has_escaping_regions(ty));
if self.region_binders_passed == 0 || !ty::type_has_escaping_regions(ty) {
}
let result = ty_fold::shift_regions(self.tcx(), self.region_binders_passed, &ty);
- debug!("shift_regions: shifted result = {}", result.repr(self.tcx()));
+ debug!("shift_regions: shifted result = {:?}", result.repr(self.tcx()));
result
}
ty::ty_err => {
tcx.sess.bug(
format!("ty_is_local invoked on unexpected type: {}",
- ty.repr(tcx))[])
+ ty.repr(tcx)).index(&FullRange))
}
}
}
span,
format!(
"consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate",
- suggested_limit)[]);
+ suggested_limit).index(&FullRange));
}
}
pub fn pending_obligations(&self) -> &[PredicateObligation<'tcx>] {
- self.predicates[]
+ self.predicates.index(&FullRange)
}
/// Attempts to select obligations using `selcx`. If `only_new_obligations` is true, then it
debug!("register_region_obligation({})",
region_obligation.repr(tcx));
- let body_id = region_obligation.cause.body_id;
- match region_obligations.entry(&body_id) {
+ match region_obligations.entry(region_obligation.cause.body_id) {
Vacant(entry) => { entry.insert(vec![region_obligation]); },
Occupied(mut entry) => { entry.get_mut().push(region_obligation); },
}
}
-
span: Span)
-> SelectionResult<'tcx, ()>
{
- debug!("type_known_to_meet_builtin_bound(ty={}, bound={})",
+ debug!("type_known_to_meet_builtin_bound(ty={}, bound={:?})",
ty.repr(infcx.tcx),
bound);
}
};
- debug!("type_known_to_meet_builtin_bound: ty={} bound={} result={}",
+ debug!("type_known_to_meet_builtin_bound: ty={} bound={:?} result={:?}",
ty.repr(infcx.tcx),
bound,
result);
span,
format!("overflow evaluating whether `{}` is `{}`",
ty.user_string(infcx.tcx),
- bound.user_string(infcx.tcx))[]);
+ bound.user_string(infcx.tcx)).as_slice());
suggest_new_overflow_limit(infcx.tcx, span);
false
}
// The `Self` type is erased, so it should not appear in list of
// arguments or return type apart from the receiver.
let ref sig = method.fty.sig;
- for &input_ty in sig.0.inputs[1..].iter() {
+ for &input_ty in sig.0.inputs.index(&(1..)).iter() {
if contains_illegal_self_type_reference(tcx, trait_def_id, input_ty) {
return Some(MethodViolationCode::ReferencesSelf);
}
ObjectSafetyViolation::SizedSelf =>
format!("SizedSelf"),
ObjectSafetyViolation::Method(ref m, code) =>
- format!("Method({},{})", m.repr(tcx), code),
+ format!("Method({},{:?})", m.repr(tcx), code),
}
}
}
selcx.tcx().sess.span_bug(
obligation.cause.span,
format!("assemble_candidates_from_object_type called with non-object: {}",
- object_ty.repr(selcx.tcx()))[]);
+ object_ty.repr(selcx.tcx())).as_slice());
}
};
let projection_bounds = data.projection_bounds_with_self_ty(selcx.tcx(), object_ty);
let result = self.evaluate_stack(&stack);
- debug!("result: {}", result);
+ debug!("result: {:?}", result);
result
}
let all_bounds =
util::transitive_bounds(
- self.tcx(), caller_trait_refs[]);
+ self.tcx(), caller_trait_refs.index(&FullRange));
let matching_bounds =
all_bounds.filter(
_ => { return Ok(()); }
};
- debug!("assemble_unboxed_candidates: self_ty={} kind={} obligation={}",
+ debug!("assemble_unboxed_candidates: self_ty={} kind={:?} obligation={}",
self_ty.repr(self.tcx()),
kind,
obligation.repr(self.tcx()));
let closure_kind = self.closure_typer.unboxed_closure_kind(closure_def_id);
- debug!("closure_kind = {}", closure_kind);
+ debug!("closure_kind = {:?}", closure_kind);
if closure_kind == kind {
candidates.vec.push(UnboxedClosureCandidate(closure_def_id, substs.clone()));
Err(error) => EvaluatedToErr(error),
}
});
- debug!("winnow_candidate depth={} result={}",
+ debug!("winnow_candidate depth={} result={:?}",
stack.obligation.recursion_depth, result);
result
}
self.tcx().sess.bug(
format!(
"asked to assemble builtin bounds of unexpected type: {}",
- self_ty.repr(self.tcx()))[]);
+ self_ty.repr(self.tcx())).index(&FullRange));
}
};
self.tcx().sess.span_bug(
obligation.cause.span,
format!("builtin bound for {} was ambig",
- obligation.repr(self.tcx()))[]);
+ obligation.repr(self.tcx())).index(&FullRange));
}
}
}
let substs =
self.rematch_impl(impl_def_id, obligation,
snapshot, &skol_map, skol_obligation_trait_ref.trait_ref);
- debug!("confirm_impl_candidate substs={}", substs);
+ debug!("confirm_impl_candidate substs={:?}", substs);
Ok(self.vtable_impl(impl_def_id, substs, obligation.cause.clone(),
obligation.recursion_depth + 1, skol_map, snapshot))
})
self.tcx().sess.span_bug(
obligation.cause.span,
format!("Fn pointer candidate for inappropriate self type: {}",
- self_ty.repr(self.tcx()))[]);
+ self_ty.repr(self.tcx())).index(&FullRange));
}
};
self.tcx().sess.bug(
format!("Impl {} was matchable against {} but now is not",
impl_def_id.repr(self.tcx()),
- obligation.repr(self.tcx()))[]);
+ obligation.repr(self.tcx())).index(&FullRange));
}
}
}
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
match *self {
ErrorCandidate => format!("ErrorCandidate"),
- BuiltinCandidate(b) => format!("BuiltinCandidate({})", b),
+ BuiltinCandidate(b) => format!("BuiltinCandidate({:?})", b),
ParamCandidate(ref a) => format!("ParamCandidate({})", a.repr(tcx)),
ImplCandidate(a) => format!("ImplCandidate({})", a.repr(tcx)),
ProjectionCandidate => format!("ProjectionCandidate"),
format!("ObjectCandidate")
}
UnboxedClosureCandidate(c, ref s) => {
- format!("UnboxedClosureCandidate({},{})", c, s.repr(tcx))
+ format!("UnboxedClosureCandidate({:?},{})", c, s.repr(tcx))
}
}
}
impl<'tcx, N> fmt::Show for VtableImplData<'tcx, N> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "VtableImpl({})", self.impl_def_id)
+ write!(f, "VtableImpl({:?})", self.impl_def_id)
}
}
impl<'tcx> fmt::Show for super::FulfillmentErrorCode<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
- super::CodeSelectionError(ref e) => write!(f, "{}", e),
- super::CodeProjectionError(ref e) => write!(f, "{}", e),
+ super::CodeSelectionError(ref e) => write!(f, "{:?}", e),
+ super::CodeProjectionError(ref e) => write!(f, "{:?}", e),
super::CodeAmbiguity => write!(f, "Ambiguity")
}
}
pub abi: abi::Abi,
}
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Show)]
pub enum FnOutput<'tcx> {
FnConverging(Ty<'tcx>),
FnDiverging
}
impl<'tcx> FnOutput<'tcx> {
+ pub fn diverges(&self) -> bool {
+ *self == FnDiverging
+ }
+
pub fn unwrap(self) -> Ty<'tcx> {
match self {
ty::FnConverging(t) => t,
}
}
+pub type PolyFnOutput<'tcx> = Binder<FnOutput<'tcx>>;
+
+impl<'tcx> PolyFnOutput<'tcx> {
+ pub fn diverges(&self) -> bool {
+ self.0.diverges()
+ }
+}
+
/// Signature of a function type, which I have arbitrarily
/// decided to use to refer to the input/output types.
///
pub type PolyFnSig<'tcx> = Binder<FnSig<'tcx>>;
+impl<'tcx> PolyFnSig<'tcx> {
+ pub fn inputs(&self) -> ty::Binder<Vec<Ty<'tcx>>> {
+ ty::Binder(self.0.inputs.clone())
+ }
+ pub fn input(&self, index: uint) -> ty::Binder<Ty<'tcx>> {
+ ty::Binder(self.0.inputs[index])
+ }
+ pub fn output(&self) -> ty::Binder<FnOutput<'tcx>> {
+ ty::Binder(self.0.output.clone())
+ }
+ pub fn variadic(&self) -> bool {
+ self.0.variadic
+ }
+}
+
#[derive(Clone, Copy, PartialEq, Eq, Hash, Show)]
pub struct ParamTy {
pub space: subst::ParamSpace,
impl<'tcx> fmt::Show for FnSig<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- // grr, without tcx not much we can do.
- write!(f, "(...)")
+ write!(f, "({:?}; variadic: {})->{:?}", self.inputs, self.variadic, self.output)
}
}
TyVar(ref v) => v.fmt(f),
IntVar(ref v) => v.fmt(f),
FloatVar(ref v) => v.fmt(f),
- FreshTy(v) => write!(f, "FreshTy({})", v),
- FreshIntTy(v) => write!(f, "FreshIntTy({})", v),
+ FreshTy(v) => write!(f, "FreshTy({:?})", v),
+ FreshIntTy(v) => write!(f, "FreshIntTy({:?})", v),
}
}
}
/// struct Foo<T,U:Bar<T>> { ... }
///
/// Here, the `Generics` for `Foo` would contain a list of bounds like
-/// `[[], [U:Bar<T>]]`. Now if there were some particular reference
-/// like `Foo<int,uint>`, then the `GenericBounds` would be `[[],
+/// `[.index(&FullRange), [U:Bar<T>]]`. Now if there were some particular reference
+/// like `Foo<int,uint>`, then the `GenericBounds` would be `[.index(&FullRange),
/// [uint:Bar<int>]]`.
#[derive(Clone, Show)]
pub struct GenericBounds<'tcx> {
_ => {
cx.sess.bug(format!("ParameterEnvironment::from_item(): \
`{}` is not an item",
- cx.map.node_to_string(id))[])
+ cx.map.node_to_string(id)).index(&FullRange))
}
}
}
};
match result {
Ok(trait_did) => trait_did,
- Err(err) => cx.sess.fatal(err[]),
+ Err(err) => cx.sess.fatal(err.index(&FullRange)),
}
}
}
bool: intern_ty(arena, interner, ty_bool),
char: intern_ty(arena, interner, ty_char),
err: intern_ty(arena, interner, ty_err),
- int: intern_ty(arena, interner, ty_int(ast::TyI)),
+ int: intern_ty(arena, interner, ty_int(ast::TyIs)),
i8: intern_ty(arena, interner, ty_int(ast::TyI8)),
i16: intern_ty(arena, interner, ty_int(ast::TyI16)),
i32: intern_ty(arena, interner, ty_int(ast::TyI32)),
i64: intern_ty(arena, interner, ty_int(ast::TyI64)),
- uint: intern_ty(arena, interner, ty_uint(ast::TyU)),
+ uint: intern_ty(arena, interner, ty_uint(ast::TyUs)),
u8: intern_ty(arena, interner, ty_uint(ast::TyU8)),
u16: intern_ty(arena, interner, ty_uint(ast::TyU16)),
u32: intern_ty(arena, interner, ty_uint(ast::TyU32)),
region_depth: flags.depth,
});
- debug!("Interned type: {} Pointer: {}",
+ debug!("Interned type: {:?} Pointer: {:?}",
ty, ty as *const _);
interner.insert(InternedTy { ty: ty }, ty);
}
&ty_tup(ref ts) => {
- self.add_tys(ts[]);
+ self.add_tys(ts.index(&FullRange));
}
&ty_bare_fn(_, ref f) => {
fn add_fn_sig(&mut self, fn_sig: &PolyFnSig) {
let mut computation = FlagComputation::new();
- computation.add_tys(fn_sig.0.inputs[]);
+ computation.add_tys(fn_sig.0.inputs.index(&FullRange));
if let ty::FnConverging(output) = fn_sig.0.output {
computation.add_ty(output);
pub fn mk_mach_int<'tcx>(tcx: &ctxt<'tcx>, tm: ast::IntTy) -> Ty<'tcx> {
match tm {
- ast::TyI => tcx.types.int,
+ ast::TyIs => tcx.types.int,
ast::TyI8 => tcx.types.i8,
ast::TyI16 => tcx.types.i16,
ast::TyI32 => tcx.types.i32,
pub fn mk_mach_uint<'tcx>(tcx: &ctxt<'tcx>, tm: ast::UintTy) -> Ty<'tcx> {
match tm {
- ast::TyU => tcx.types.uint,
+ ast::TyUs => tcx.types.uint,
ast::TyU8 => tcx.types.u8,
ast::TyU16 => tcx.types.u16,
ast::TyU32 => tcx.types.u32,
fn bound_list_is_sorted(bounds: &[ty::PolyProjectionPredicate]) -> bool {
bounds.len() == 0 ||
- bounds[1..].iter().enumerate().all(
+ bounds.index(&(1..)).iter().enumerate().all(
|(index, bound)| bounds[index].sort_key() <= bound.sort_key())
}
ty_str => mk_mach_uint(cx, ast::TyU8),
ty_open(ty) => sequence_element_type(cx, ty),
_ => cx.sess.bug(format!("sequence_element_type called on non-sequence value: {}",
- ty_to_string(cx, ty))[]),
+ ty_to_string(cx, ty)).index(&FullRange)),
}
}
let result = match ty.sty {
// uint and int are ffi-unsafe
- ty_uint(ast::TyU) | ty_int(ast::TyI) => {
+ ty_uint(ast::TyUs) | ty_int(ast::TyIs) => {
TC::ReachesFfiUnsafe
}
ty_struct(did, substs) => {
let flds = struct_fields(cx, did, substs);
let mut res =
- TypeContents::union(flds[],
+ TypeContents::union(flds.index(&FullRange),
|f| tc_mt(cx, f.mt, cache));
if !lookup_repr_hints(cx, did).contains(&attr::ReprExtern) {
}
ty_tup(ref tys) => {
- TypeContents::union(tys[],
+ TypeContents::union(tys.index(&FullRange),
|ty| tc_ty(cx, *ty, cache))
}
ty_enum(did, substs) => {
let variants = substd_enum_variants(cx, did, substs);
let mut res =
- TypeContents::union(variants[], |variant| {
- TypeContents::union(variant.args[],
+ TypeContents::union(variants.index(&FullRange), |variant| {
+ TypeContents::union(variant.args.index(&FullRange),
|arg_ty| {
tc_ty(cx, *arg_ty, cache)
})
match cache.borrow().get(&ty) {
None => {}
Some(&result) => {
- debug!("type_impls_bound({}, {}) = {} (cached)",
+ debug!("type_impls_bound({}, {:?}) = {:?} (cached)",
ty.repr(param_env.tcx),
bound,
result);
let is_impld = traits::type_known_to_meet_builtin_bound(&infcx, param_env, ty, bound, span);
- debug!("type_impls_bound({}, {}) = {}",
+ debug!("type_impls_bound({}, {:?}) = {:?}",
ty.repr(param_env.tcx),
bound,
is_impld);
pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool {
fn type_requires<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec<DefId>,
r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool {
- debug!("type_requires({}, {})?",
+ debug!("type_requires({:?}, {:?})?",
::util::ppaux::ty_to_string(cx, r_ty),
::util::ppaux::ty_to_string(cx, ty));
let r = r_ty == ty || subtypes_require(cx, seen, r_ty, ty);
- debug!("type_requires({}, {})? {}",
+ debug!("type_requires({:?}, {:?})? {:?}",
::util::ppaux::ty_to_string(cx, r_ty),
::util::ppaux::ty_to_string(cx, ty),
r);
fn subtypes_require<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec<DefId>,
r_ty: Ty<'tcx>, ty: Ty<'tcx>) -> bool {
- debug!("subtypes_require({}, {})?",
+ debug!("subtypes_require({:?}, {:?})?",
::util::ppaux::ty_to_string(cx, r_ty),
::util::ppaux::ty_to_string(cx, ty));
ty_unboxed_closure(..) => {
// this check is run on type definitions, so we don't expect to see
// inference by-products or unboxed closure types
- cx.sess.bug(format!("requires check invoked on inapplicable type: {}", ty)[])
+ cx.sess.bug(format!("requires check invoked on inapplicable type: {:?}",
+ ty).as_slice())
}
ty_tup(ref ts) => {
}
};
- debug!("subtypes_require({}, {})? {}",
+ debug!("subtypes_require({:?}, {:?})? {:?}",
::util::ppaux::ty_to_string(cx, r_ty),
::util::ppaux::ty_to_string(cx, ty),
r);
ty_unboxed_closure(..) => {
// this check is run on type definitions, so we don't expect to see
// unboxed closure types
- cx.sess.bug(format!("requires check invoked on inapplicable type: {}", ty)[])
+ cx.sess.bug(format!("requires check invoked on inapplicable type: {:?}",
+ ty).as_slice())
}
_ => Representable,
}
fn is_type_structurally_recursive<'tcx>(cx: &ctxt<'tcx>, sp: Span,
seen: &mut Vec<Ty<'tcx>>,
ty: Ty<'tcx>) -> Representability {
- debug!("is_type_structurally_recursive: {}",
+ debug!("is_type_structurally_recursive: {:?}",
::util::ppaux::ty_to_string(cx, ty));
match ty.sty {
match iter.next() {
Some(&seen_type) => {
if same_struct_or_enum_def_id(seen_type, did) {
- debug!("SelfRecursive: {} contains {}",
+ debug!("SelfRecursive: {:?} contains {:?}",
::util::ppaux::ty_to_string(cx, seen_type),
::util::ppaux::ty_to_string(cx, ty));
return SelfRecursive;
for &seen_type in iter {
if same_type(ty, seen_type) {
- debug!("ContainsRecursive: {} contains {}",
+ debug!("ContainsRecursive: {:?} contains {:?}",
::util::ppaux::ty_to_string(cx, seen_type),
::util::ppaux::ty_to_string(cx, ty));
return ContainsRecursive;
}
}
- debug!("is_type_representable: {}",
+ debug!("is_type_representable: {:?}",
::util::ppaux::ty_to_string(cx, ty));
// To avoid a stack overflow when checking an enum variant or struct that
// of seen types and check recursion for each of them (issues #3008, #3779).
let mut seen: Vec<Ty> = Vec::new();
let r = is_type_structurally_recursive(cx, sp, &mut seen, ty);
- debug!("is_type_representable: {} is {}",
+ debug!("is_type_representable: {:?} is {:?}",
::util::ppaux::ty_to_string(cx, ty), r);
r
}
pub fn type_is_uint(ty: Ty) -> bool {
match ty.sty {
- ty_infer(IntVar(_)) | ty_uint(ast::TyU) => true,
+ ty_infer(IntVar(_)) | ty_uint(ast::TyUs) => true,
_ => false
}
}
pub fn type_is_machine(ty: Ty) -> bool {
match ty.sty {
- ty_int(ast::TyI) | ty_uint(ast::TyU) => false,
+ ty_int(ast::TyIs) | ty_uint(ast::TyUs) => false,
ty_int(..) | ty_uint(..) | ty_float(..) => true,
_ => false
}
match ty.sty {
ty_open(ty) => mk_rptr(cx, cx.mk_region(ReStatic), mt {ty: ty, mutbl:ast::MutImmutable}),
_ => cx.sess.bug(format!("Trying to close a non-open type {}",
- ty_to_string(cx, ty))[])
+ ty_to_string(cx, ty)).index(&FullRange))
}
}
Some(ty) => ty.clone(),
None => cx.sess.bug(
format!("node_id_to_trait_ref: no trait ref for node `{}`",
- cx.map.node_to_string(id))[])
+ cx.map.node_to_string(id)).index(&FullRange))
}
}
Some(ty) => ty,
None => cx.sess.bug(
format!("node_id_to_type: no type for node `{}`",
- cx.map.node_to_string(id))[])
+ cx.map.node_to_string(id)).index(&FullRange))
}
}
match fty.sty {
ty_bare_fn(_, ref f) => f.sig.0.variadic,
ref s => {
- panic!("fn_is_variadic() called on non-fn type: {}", s)
+ panic!("fn_is_variadic() called on non-fn type: {:?}", s)
}
}
}
match fty.sty {
ty_bare_fn(_, ref f) => &f.sig,
ref s => {
- panic!("ty_fn_sig() called on non-fn type: {}", s)
+ panic!("ty_fn_sig() called on non-fn type: {:?}", s)
}
}
}
}
// Type accessors for substructures of types
-pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> &'tcx [Ty<'tcx>] {
- ty_fn_sig(fty).0.inputs.as_slice()
+pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> ty::Binder<Vec<Ty<'tcx>>> {
+ ty_fn_sig(fty).inputs()
}
pub fn ty_closure_store(fty: Ty) -> TraitStore {
UniqTraitStore
}
ref s => {
- panic!("ty_closure_store() called on non-closure type: {}", s)
+ panic!("ty_closure_store() called on non-closure type: {:?}", s)
}
}
}
-pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> FnOutput<'tcx> {
+pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> Binder<FnOutput<'tcx>> {
match fty.sty {
- ty_bare_fn(_, ref f) => f.sig.0.output,
+ ty_bare_fn(_, ref f) => f.sig.output(),
ref s => {
- panic!("ty_fn_ret() called on non-fn type: {}", s)
+ panic!("ty_fn_ret() called on non-fn type: {:?}", s)
}
}
}
ref s => {
tcx.sess.span_bug(
span,
- format!("ty_region() invoked on an inappropriate ty: {}",
- s)[]);
+ format!("ty_region() invoked on an inappropriate ty: {:?}",
+ s).index(&FullRange));
}
}
}
e.span
}
Some(f) => {
- cx.sess.bug(format!("Node id {} is not an expr: {}",
+ cx.sess.bug(format!("Node id {} is not an expr: {:?}",
id,
- f)[]);
+ f).index(&FullRange));
}
None => {
cx.sess.bug(format!("Node id {} is not present \
- in the node map", id)[]);
+ in the node map", id).index(&FullRange));
}
}
}
}
_ => {
cx.sess.bug(
- format!("Variable id {} maps to {}, not local",
+ format!("Variable id {} maps to {:?}, not local",
id,
- pat)[]);
+ pat).index(&FullRange));
}
}
}
r => {
- cx.sess.bug(format!("Variable id {} maps to {}, not local",
+ cx.sess.bug(format!("Variable id {} maps to {:?}, not local",
id,
- r)[]);
+ r).index(&FullRange));
}
}
}
return match adjustment {
Some(adjustment) => {
match *adjustment {
- AdjustReifyFnPointer(_) => {
+ AdjustReifyFnPointer(_) => {
match unadjusted_ty.sty {
ty::ty_bare_fn(Some(_), b) => {
ty::mk_bare_fn(cx, None, b)
ref b => {
cx.sess.bug(
format!("AdjustReifyFnPointer adjustment on non-fn-item: \
- {}",
- b)[]);
+ {:?}",
+ b).index(&FullRange));
}
}
}
let method_call = MethodCall::autoderef(expr_id, i);
match method_type(method_call) {
Some(method_ty) => {
- if let ty::FnConverging(result_type) = ty_fn_ret(method_ty) {
- adjusted_ty = result_type;
- }
+ // overloaded deref operators have all late-bound
+ // regions fully instantiated and coverge
+ let fn_ret =
+ ty::assert_no_late_bound_regions(cx,
+ &ty_fn_ret(method_ty));
+ adjusted_ty = fn_ret.unwrap();
}
None => {}
}
{}",
i,
ty_to_string(cx, adjusted_ty))
- []);
+ .index(&FullRange));
}
}
}
mk_vec(cx, ty, None)
}
_ => cx.sess.span_bug(span,
- format!("UnsizeLength with bad sty: {}",
- ty_to_string(cx, ty))[])
+ format!("UnsizeLength with bad sty: {:?}",
+ ty_to_string(cx, ty)).index(&FullRange))
},
&UnsizeStruct(box ref k, tp_index) => match ty.sty {
ty_struct(did, substs) => {
mk_struct(cx, did, cx.mk_substs(unsized_substs))
}
_ => cx.sess.span_bug(span,
- format!("UnsizeStruct with bad sty: {}",
- ty_to_string(cx, ty))[])
+ format!("UnsizeStruct with bad sty: {:?}",
+ ty_to_string(cx, ty)).index(&FullRange))
},
&UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => {
mk_trait(cx, principal.clone(), bounds.clone())
Some(&def) => def,
None => {
tcx.sess.span_bug(expr.span, format!(
- "no def-map entry for expr {}", expr.id)[]);
+ "no def-map entry for expr {}", expr.id).index(&FullRange));
}
}
}
def => {
tcx.sess.span_bug(
expr.span,
- format!("uncategorized def for expr {}: {}",
+ format!("uncategorized def for expr {}: {:?}",
expr.id,
- def)[]);
+ def).index(&FullRange));
}
}
}
let mut i = 0u;
for f in fields.iter() { if f.name == name { return i; } i += 1u; }
tcx.sess.bug(format!(
- "no field named `{}` found in the list of fields `{}`",
+ "no field named `{}` found in the list of fields `{:?}`",
token::get_name(name),
fields.iter()
.map(|f| token::get_name(f.name).get().to_string())
- .collect::<Vec<String>>())[]);
+ .collect::<Vec<String>>()).index(&FullRange));
}
pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem])
terr_mismatch => "types differ".to_string(),
terr_unsafety_mismatch(values) => {
format!("expected {} fn, found {} fn",
- values.expected.to_string(),
- values.found.to_string())
+ values.expected,
+ values.found)
}
terr_abi_mismatch(values) => {
format!("expected {} fn, found {} fn",
- values.expected.to_string(),
- values.found.to_string())
+ values.expected,
+ values.found)
}
terr_onceness_mismatch(values) => {
format!("expected {} fn, found {} fn",
- values.expected.to_string(),
- values.found.to_string())
+ values.expected,
+ values.found)
}
terr_sigil_mismatch(values) => {
format!("expected {}, found {}",
"expected an integral type, found `char`".to_string()
}
terr_int_mismatch(ref values) => {
- format!("expected `{}`, found `{}`",
- values.expected.to_string(),
- values.found.to_string())
+ format!("expected `{:?}`, found `{:?}`",
+ values.expected,
+ values.found)
}
terr_float_mismatch(ref values) => {
- format!("expected `{}`, found `{}`",
- values.expected.to_string(),
- values.found.to_string())
+ format!("expected `{:?}`, found `{:?}`",
+ values.expected,
+ values.found)
}
terr_variadic_mismatch(ref values) => {
format!("expected {} fn, found {} function",
match item.node {
ItemTrait(_, _, _, ref ms) => {
let (_, p) =
- ast_util::split_trait_methods(ms[]);
+ ast_util::split_trait_methods(ms.index(&FullRange));
p.iter()
.map(|m| {
match impl_or_trait_item(
}).collect()
}
_ => {
- cx.sess.bug(format!("provided_trait_methods: `{}` is \
+ cx.sess.bug(format!("provided_trait_methods: `{:?}` is \
not a trait",
- id)[])
+ id).index(&FullRange))
}
}
}
_ => {
- cx.sess.bug(format!("provided_trait_methods: `{}` is not a \
+ cx.sess.bug(format!("provided_trait_methods: `{:?}` is not a \
trait",
- id)[])
+ id).index(&FullRange))
}
}
} else {
}
if def_id.krate == ast::LOCAL_CRATE {
- panic!("No def'n found for {} in tcx.{}", def_id, descr);
+ panic!("No def'n found for {:?} in tcx.{}", def_id, descr);
}
let v = load_external();
map.insert(def_id, v.clone());
-> Option<Rc<TraitRef<'tcx>>> {
memoized(&cx.impl_trait_cache, id, |id: ast::DefId| {
if id.krate == ast::LOCAL_CRATE {
- debug!("(impl_trait_ref) searching for trait impl {}", id);
+ debug!("(impl_trait_ref) searching for trait impl {:?}", id);
match cx.map.find(id.node) {
Some(ast_map::NodeItem(item)) => {
match item.node {
match ast_variant.node.kind {
ast::TupleVariantKind(ref args) => {
let arg_tys = if args.len() > 0 {
- ty_fn_args(ctor_ty).iter().map(|a| *a).collect()
+ // the regions in the argument types come from the
+ // enum def'n, and hence will all be early bound
+ ty::assert_no_late_bound_regions(cx, &ty_fn_args(ctor_ty))
} else {
Vec::new()
};
};
},
ast::StructVariantKind(ref struct_def) => {
-
- let fields: &[StructField] = struct_def.fields[];
+ let fields: &[StructField] = struct_def.fields.index(&FullRange);
assert!(fields.len() > 0);
cx.sess
.span_err(e.span,
format!("expected constant: {}",
- *err)[]);
+ *err).index(&FullRange));
}
},
None => {}
{
let trait_def = lookup_trait_def(tcx, trait_ref.def_id());
- debug!("bounds_for_trait_ref(trait_def={}, trait_ref={})",
+ debug!("bounds_for_trait_ref(trait_def={:?}, trait_ref={:?})",
trait_def.repr(tcx), trait_ref.repr(tcx));
// The interaction between HRTB and supertraits is not entirely
node_id_to_type(tcx, id.node)
} else {
let mut tcache = tcx.tcache.borrow_mut();
- let pty = tcache.entry(&id).get().unwrap_or_else(
+ let pty = tcache.entry(id).get().unwrap_or_else(
|vacant_entry| vacant_entry.insert(csearch::get_field_type(tcx, struct_id, id)));
pty.ty
};
_ => {
cx.sess.bug(
format!("ID not mapped to struct fields: {}",
- cx.map.node_to_string(did.node))[]);
+ cx.map.node_to_string(did.node)).index(&FullRange));
}
}
} else {
pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec<field<'tcx>> {
v.iter().enumerate().map(|(i, &f)| {
field {
- name: token::intern(i.to_string()[]),
+ name: token::intern(i.to_string().index(&FullRange)),
mt: mt {
ty: f,
mutbl: MutImmutable
return tbl[tycat(cx, ty) as uint ][opcat(op) as uint];
}
-/// Returns an equivalent type with all the typedefs and self regions removed.
-pub fn normalize_ty<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
- let u = TypeNormalizer(cx).fold_ty(ty);
- return u;
-
- struct TypeNormalizer<'a, 'tcx: 'a>(&'a ctxt<'tcx>);
-
- impl<'a, 'tcx> TypeFolder<'tcx> for TypeNormalizer<'a, 'tcx> {
- fn tcx(&self) -> &ctxt<'tcx> { let TypeNormalizer(c) = *self; c }
-
- fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
- match self.tcx().normalized_cache.borrow().get(&ty).cloned() {
- None => {}
- Some(u) => return u
- }
-
- let t_norm = ty_fold::super_fold_ty(self, ty);
- self.tcx().normalized_cache.borrow_mut().insert(ty, t_norm);
- return t_norm;
- }
-
- fn fold_region(&mut self, _: ty::Region) -> ty::Region {
- ty::ReStatic
- }
-
- fn fold_substs(&mut self,
- substs: &subst::Substs<'tcx>)
- -> subst::Substs<'tcx> {
- subst::Substs { regions: subst::ErasedRegions,
- types: substs.types.fold_with(self) }
- }
- }
-}
-
// Returns the repeat count for a repeating vector expression.
pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint {
match const_eval::eval_const_expr_partial(tcx, count_expr) {
};
tcx.sess.span_err(count_expr.span, format!(
"expected positive integer for repeat count, found {}",
- found)[]);
+ found).index(&FullRange));
}
Err(_) => {
let found = match count_expr.node {
};
tcx.sess.span_err(count_expr.span, format!(
"expected constant integer for repeat count, found {}",
- found)[]);
+ found).index(&FullRange));
}
}
0
predicates: Vec<ty::Predicate<'tcx>>)
-> Vec<ty::Region>
{
- debug!("required_region_bounds(erased_self_ty={}, predicates={})",
+ debug!("required_region_bounds(erased_self_ty={:?}, predicates={:?})",
erased_self_ty.repr(tcx),
predicates.repr(tcx));
return
}
- debug!("populate_implementations_for_type_if_necessary: searching for {}", type_id);
+ debug!("populate_implementations_for_type_if_necessary: searching for {:?}", type_id);
let mut inherent_impls = Vec::new();
csearch::each_implementation_for_type(&tcx.sess.cstore, type_id,
mt.mutbl.hash(state);
};
let fn_sig = |&: state: &mut sip::SipState, sig: &Binder<FnSig<'tcx>>| {
- let sig = anonymize_late_bound_regions(tcx, sig);
+ let sig = anonymize_late_bound_regions(tcx, sig).0;
for a in sig.inputs.iter() { helper(tcx, *a, svh, state); }
if let ty::FnConverging(output) = sig.output {
helper(tcx, output, svh, state);
did(state, data.principal_def_id());
hash!(data.bounds);
- let principal = anonymize_late_bound_regions(tcx, &data.principal);
+ let principal = anonymize_late_bound_regions(tcx, &data.principal).0;
for subty in principal.substs.types.iter() {
helper(tcx, *subty, svh, state);
}
record_region_bounds(tcx, &bounds);
- debug!("construct_parameter_environment: free_id={} free_subst={} bounds={}",
+ debug!("construct_parameter_environment: free_id={:?} free_subst={:?} bounds={:?}",
free_id,
free_substs.repr(tcx),
bounds.repr(tcx));
types: &mut VecPerParamSpace<Ty<'tcx>>,
defs: &[TypeParameterDef<'tcx>]) {
for def in defs.iter() {
- debug!("construct_parameter_environment(): push_types_from_defs: def={}",
+ debug!("construct_parameter_environment(): push_types_from_defs: def={:?}",
def.repr(tcx));
let ty = ty::mk_param_from_def(tcx, def);
types.push(def.space, ty);
- }
+ }
}
fn record_region_bounds<'tcx>(tcx: &ty::ctxt<'tcx>, bounds: &GenericBounds<'tcx>) {
- debug!("record_region_bounds(bounds={})", bounds.repr(tcx));
+ debug!("record_region_bounds(bounds={:?})", bounds.repr(tcx));
for predicate in bounds.predicates.iter() {
match *predicate {
{
match tcx.freevars.borrow().get(&fid) {
None => f(&[]),
- Some(d) => f(d[])
+ Some(d) => f(d.index(&FullRange))
}
}
count_late_bound_regions(tcx, value) > 0
}
+pub fn assert_no_late_bound_regions<'tcx, T>(
+ tcx: &ty::ctxt<'tcx>,
+ value: &Binder<T>)
+ -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx> + Clone
+{
+ assert!(!binds_late_bound_regions(tcx, value));
+ value.0.clone()
+}
+
/// Replace any late-bound regions bound in `value` with `'static`. Useful in trans but also
/// method lookup and a few other places where precise region relationships are not required.
pub fn erase_late_bound_regions<'tcx, T>(
pub fn anonymize_late_bound_regions<'tcx, T>(
tcx: &ctxt<'tcx>,
sig: &Binder<T>)
- -> T
+ -> Binder<T>
where T : TypeFoldable<'tcx> + Repr<'tcx>,
{
let mut counter = 0;
- replace_late_bound_regions(tcx, sig, |_, db| {
+ ty::Binder(replace_late_bound_regions(tcx, sig, |_, db| {
counter += 1;
ReLateBound(db, BrAnon(counter))
- }).0
+ }).0)
}
/// Replaces the late-bound-regions in `value` that are bound by `value`.
debug!("region={}", region.repr(tcx));
match region {
ty::ReLateBound(debruijn, br) if debruijn.depth == current_depth => {
- * map.entry(&br).get().unwrap_or_else(
+ * map.entry(br).get().unwrap_or_else(
|vacant_entry| vacant_entry.insert(mapf(br, debruijn)))
}
_ => {
}
});
- debug!("resulting map: {} value: {}", map, value.repr(tcx));
+ debug!("resulting map: {:?} value: {:?}", map, value.repr(tcx));
(value, map)
}
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
match *self {
AutoPtr(a, b, ref c) => {
- format!("AutoPtr({},{},{})", a.repr(tcx), b, c.repr(tcx))
+ format!("AutoPtr({},{:?},{})", a.repr(tcx), b, c.repr(tcx))
}
AutoUnsize(ref a) => {
format!("AutoUnsize({})", a.repr(tcx))
format!("AutoUnsizeUniq({})", a.repr(tcx))
}
AutoUnsafe(ref a, ref b) => {
- format!("AutoUnsafe({},{})", a, b.repr(tcx))
+ format!("AutoUnsafe({:?},{})", a, b.repr(tcx))
}
}
}
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
match *self {
vtable_static(def_id, ref tys, ref vtable_res) => {
- format!("vtable_static({}:{}, {}, {})",
+ format!("vtable_static({:?}:{}, {}, {})",
def_id,
ty::item_path_str(tcx, def_id),
tys.repr(tcx),
}
vtable_param(x, y) => {
- format!("vtable_param({}, {})", x, y)
+ format!("vtable_param({:?}, {})", x, y)
}
vtable_unboxed_closure(def_id) => {
- format!("vtable_unboxed_closure({})", def_id)
+ format!("vtable_unboxed_closure({:?})", def_id)
}
vtable_error => {
impl<'tcx> Repr<'tcx> for ClosureTy<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
- format!("ClosureTy({},{},{},{},{},{})",
+ format!("ClosureTy({},{},{:?},{},{},{})",
self.unsafety,
self.onceness,
self.store,
_ => {
debug!("RegionFolder.fold_region({}) folding free region (current_depth={})",
r.repr(self.tcx()), self.current_depth);
- self.fld_r.call_mut((r, self.current_depth))
+ (self.fld_r)(r, self.current_depth)
}
}
}
fn tcx(&self) -> &ty::ctxt<'tcx> { self.tcx }
fn fold_region(&mut self, r: ty::Region) -> ty::Region {
+ // because whether or not a region is bound affects subtyping,
+ // we can't erase the bound/free distinction, but we can
+ // replace all free regions with 'static
match r {
ty::ReLateBound(..) | ty::ReEarlyBound(..) => r,
_ => ty::ReStatic
type Item = Ty<'tcx>;
fn next(&mut self) -> Option<Ty<'tcx>> {
- debug!("next(): stack={}", self.stack);
+ debug!("next(): stack={:?}", self.stack);
match self.stack.pop() {
None => {
return None;
Some(ty) => {
self.last_subtree = self.stack.len();
self.push_subtypes(ty);
- debug!("next: stack={}", self.stack);
+ debug!("next: stack={:?}", self.stack);
Some(ty)
}
}
// this is fatal: there are almost certainly macros we need
// inside this crate, so continue would spew "macro undefined"
// errors
- Err(err) => self.sess.span_fatal(vi.span, err[])
+ Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange))
};
unsafe {
let registrar =
- match lib.symbol(symbol[]) {
+ match lib.symbol(symbol.index(&FullRange)) {
Ok(registrar) => {
mem::transmute::<*mut u8,PluginRegistrarFun>(registrar)
}
// again fatal if we can't register macros
- Err(err) => self.sess.span_fatal(vi.span, err[])
+ Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange))
};
// Intentionally leak the dynamic library. We can't ever unload it
("parse-only", "Parse only; do not compile, assemble, or link", PARSE_ONLY),
("no-trans", "Run all passes except translation; no output", NO_TRANS),
("no-analysis", "Parse and expand the source, but run no analysis and",
- NO_TRANS),
+ NO_ANALYSIS),
("unstable-options", "Adds unstable command line options to rustc interface",
UNSTABLE_OPTIONS),
("print-enum-sizes", "Print the size of enums and their variants", PRINT_ENUM_SIZES),
match (value, opt_type_desc) {
(Some(..), None) => {
early_error(format!("codegen option `{}` takes no \
- value", key)[])
+ value", key).index(&FullRange))
}
(None, Some(type_desc)) => {
early_error(format!("codegen option `{0}` requires \
{1} (-C {0}=<value>)",
- key, type_desc)[])
+ key, type_desc).index(&FullRange))
}
(Some(value), Some(type_desc)) => {
early_error(format!("incorrect value `{}` for codegen \
option `{}` - {} was expected",
- value, key, type_desc)[])
+ value, key, type_desc).index(&FullRange))
}
(None, None) => unreachable!()
}
}
if !found {
early_error(format!("unknown codegen option: `{}`",
- key)[]);
+ key).index(&FullRange));
}
}
return cg;
pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
use syntax::parse::token::intern_and_get_ident as intern;
- let end = sess.target.target.target_endian[];
- let arch = sess.target.target.arch[];
- let wordsz = sess.target.target.target_word_size[];
- let os = sess.target.target.target_os[];
+ let end = sess.target.target.target_endian.index(&FullRange);
+ let arch = sess.target.target.arch.index(&FullRange);
+ let wordsz = sess.target.target.target_word_size.index(&FullRange);
+ let os = sess.target.target.target_os.index(&FullRange);
let fam = match sess.target.target.options.is_like_windows {
true => InternedString::new("windows"),
append_configuration(&mut user_cfg, InternedString::new("test"))
}
let mut v = user_cfg.into_iter().collect::<Vec<_>>();
- v.push_all(default_cfg[]);
+ v.push_all(default_cfg.index(&FullRange));
v
}
pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config {
- let target = match Target::search(opts.target_triple[]) {
+ let target = match Target::search(opts.target_triple.index(&FullRange)) {
Ok(t) => t,
Err(e) => {
- sp.handler().fatal((format!("Error loading target specification: {}", e))[]);
+ sp.handler().fatal((format!("Error loading target specification: {}", e)).as_slice());
}
};
- let (int_type, uint_type) = match target.target_word_size[] {
+ let (int_type, uint_type) = match target.target_word_size.index(&FullRange) {
"32" => (ast::TyI32, ast::TyU32),
"64" => (ast::TyI64, ast::TyU64),
w => sp.handler().fatal((format!("target specification was invalid: unrecognized \
- target-word-size {}", w))[])
+ target-word-size {}", w)).index(&FullRange))
};
Config {
let unparsed_crate_types = matches.opt_strs("crate-type");
let crate_types = parse_crate_types_from_list(unparsed_crate_types)
- .unwrap_or_else(|e| early_error(e[]));
+ .unwrap_or_else(|e| early_error(e.index(&FullRange)));
let mut lint_opts = vec!();
let mut describe_lints = false;
}
if this_bit == 0 {
early_error(format!("unknown debug flag: {}",
- *debug_flag)[])
+ *debug_flag).index(&FullRange))
}
debugging_opts |= this_bit;
}
"dep-info" => OutputTypeDepInfo,
_ => {
early_error(format!("unknown emission type: `{}`",
- part)[])
+ part).index(&FullRange))
}
};
output_types.push(output_type)
Some(arg) => {
early_error(format!("optimization level needs to be \
between 0-3 (instead was `{}`)",
- arg)[]);
+ arg).index(&FullRange));
}
}
} else {
Some(arg) => {
early_error(format!("debug info level needs to be between \
0-2 (instead was `{}`)",
- arg)[]);
+ arg).index(&FullRange));
}
}
} else {
let mut search_paths = SearchPaths::new();
for s in matches.opt_strs("L").iter() {
- search_paths.add_path(s[]);
+ search_paths.add_path(s.index(&FullRange));
}
let libs = matches.opt_strs("l").into_iter().map(|s| {
s => {
early_error(format!("unknown library kind `{}`, expected \
one of dylib, framework, or static",
- s)[]);
+ s).as_slice());
}
};
return (name.to_string(), kind)
(_, s) => {
early_error(format!("unknown library kind `{}`, expected \
one of dylib, framework, or static",
- s)[]);
+ s).index(&FullRange));
}
};
(name.to_string(), kind)
--debuginfo");
}
- let color = match matches.opt_str("color").as_ref().map(|s| s[]) {
+ let color = match matches.opt_str("color").as_ref().map(|s| s.index(&FullRange)) {
Some("auto") => Auto,
Some("always") => Always,
Some("never") => Never,
Some(arg) => {
early_error(format!("argument for --color must be auto, always \
or never (instead was `{}`)",
- arg)[])
+ arg).index(&FullRange))
}
};
None => early_error("--extern value must be of the format `foo=bar`"),
};
- match externs.entry(&name.to_string()) {
+ match externs.entry(name.to_string()) {
Vacant(entry) => { entry.insert(vec![location.to_string()]); },
Occupied(mut entry) => { entry.get_mut().push(location.to_string()); },
}
#[test]
fn test_switch_implies_cfg_test() {
let matches =
- &match getopts(&["--test".to_string()], optgroups()[]) {
+ &match getopts(&["--test".to_string()], optgroups().index(&FullRange)) {
Ok(m) => m,
Err(f) => panic!("test_switch_implies_cfg_test: {}", f)
};
let sessopts = build_session_options(matches);
let sess = build_session(sessopts, None, registry);
let cfg = build_configuration(&sess);
- assert!((attr::contains_name(cfg[], "test")));
+ assert!((attr::contains_name(cfg.index(&FullRange), "test")));
}
// When the user supplies --test and --cfg test, don't implicitly add
fn test_switch_implies_cfg_test_unless_cfg_test() {
let matches =
&match getopts(&["--test".to_string(), "--cfg=test".to_string()],
- optgroups()[]) {
+ optgroups().index(&FullRange)) {
Ok(m) => m,
Err(f) => {
panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f)
{
let matches = getopts(&[
"-Awarnings".to_string()
- ], optgroups()[]).unwrap();
+ ], optgroups().index(&FullRange)).unwrap();
let registry = diagnostics::registry::Registry::new(&[]);
let sessopts = build_session_options(&matches);
let sess = build_session(sessopts, None, registry);
let matches = getopts(&[
"-Awarnings".to_string(),
"-Dwarnings".to_string()
- ], optgroups()[]).unwrap();
+ ], optgroups().index(&FullRange)).unwrap();
let registry = diagnostics::registry::Registry::new(&[]);
let sessopts = build_session_options(&matches);
let sess = build_session(sessopts, None, registry);
{
let matches = getopts(&[
"-Adead_code".to_string()
- ], optgroups()[]).unwrap();
+ ], optgroups().index(&FullRange)).unwrap();
let registry = diagnostics::registry::Registry::new(&[]);
let sessopts = build_session_options(&matches);
let sess = build_session(sessopts, None, registry);
// cases later on
pub fn impossible_case(&self, sp: Span, msg: &str) -> ! {
self.span_bug(sp,
- format!("impossible case reached: {}", msg)[]);
+ format!("impossible case reached: {}", msg).index(&FullRange));
}
pub fn verbose(&self) -> bool { self.debugging_opt(config::VERBOSE) }
pub fn time_passes(&self) -> bool { self.debugging_opt(config::TIME_PASSES) }
}
pub fn target_filesearch(&self, kind: PathKind) -> filesearch::FileSearch {
filesearch::FileSearch::new(self.sysroot(),
- self.opts.target_triple[],
+ self.opts.target_triple.index(&FullRange),
&self.opts.search_paths,
kind)
}
// to make debug output more readable.
debug!(">>");
let r = op();
- debug!("<< (Result = {})", r);
+ debug!("<< (Result = {:?})", r);
r
}
for c in range(0u32, MAX as u32)
.filter_map(|i| from_u32(i))
.map(|i| i.to_string()) {
- assert_eq!(lev_distance(c[], c[]), 0);
+ assert_eq!(lev_distance(c.index(&FullRange), c.index(&FullRange)), 0);
}
let a = "\nMäry häd ä little lämb\n\nLittle lämb\n";
(ref str, Some(span)) => {
cx.sess.span_note(
span,
- format!("{}{}{}", prefix, *str, suffix)[]);
+ format!("{}{}{}", prefix, *str, suffix).index(&FullRange));
Some(span)
}
(ref str, None) => {
cx.sess.note(
- format!("{}{}{}", prefix, *str, suffix)[]);
+ format!("{}{}{}", prefix, *str, suffix).index(&FullRange));
None
}
}
}
Some(_) | None => {
// this really should not happen
- (format!("unknown scope: {}. Please report a bug.", scope), None)
+ (format!("unknown scope: {:?}. Please report a bug.", scope), None)
}
}
}
}
Some(_) | None => {
// this really should not happen
- (format!("{} unknown free region bounded by scope {}", prefix, fr.scope), None)
+ (format!("{} unknown free region bounded by scope {:?}", prefix, fr.scope), None)
}
}
}
// I believe these cases should not occur (except when debugging,
// perhaps)
ty::ReInfer(_) | ty::ReLateBound(..) => {
- (format!("lifetime {}", region), None)
+ (format!("lifetime {:?}", region), None)
}
};
};
if abi != abi::Rust {
- s.push_str(format!("extern {} ", abi.to_string())[]);
+ s.push_str(format!("extern {} ", abi.to_string()).index(&FullRange));
};
s.push_str("fn");
Some(def_id) => {
s.push_str(" {");
let path_str = ty::item_path_str(cx, def_id);
- s.push_str(path_str[]);
+ s.push_str(path_str.index(&FullRange));
s.push_str("}");
}
None => { }
match cty.store {
ty::UniqTraitStore => {}
ty::RegionTraitStore(region, _) => {
- s.push_str(region_to_string(cx, "", true, region)[]);
+ s.push_str(region_to_string(cx, "", true, region).index(&FullRange));
}
}
assert_eq!(cty.onceness, ast::Once);
s.push_str("proc");
push_sig_to_string(cx, &mut s, '(', ')', &cty.sig,
- bounds_str[]);
+ bounds_str.index(&FullRange));
}
ty::RegionTraitStore(..) => {
match cty.onceness {
ast::Once => s.push_str("once ")
}
push_sig_to_string(cx, &mut s, '|', '|', &cty.sig,
- bounds_str[]);
+ bounds_str.index(&FullRange));
}
}
ty::FnConverging(t) => {
if !ty::type_is_nil(t) {
s.push_str(" -> ");
- s.push_str(ty_to_string(cx, t)[]);
+ s.push_str(ty_to_string(cx, t).index(&FullRange));
}
}
ty::FnDiverging => {
}
ty_rptr(r, ref tm) => {
let mut buf = region_ptr_to_string(cx, *r);
- buf.push_str(mt_to_string(cx, tm)[]);
+ buf.push_str(mt_to_string(cx, tm).index(&FullRange));
buf
}
ty_open(typ) =>
.iter()
.map(|elem| ty_to_string(cx, *elem))
.collect::<Vec<_>>();
- match strs[] {
+ match strs.index(&FullRange) {
[ref string] => format!("({},)", string),
strs => format!("({})", strs.connect(", "))
}
0
};
- for t in tps[..tps.len() - num_defaults].iter() {
+ for t in tps.index(&(0..(tps.len() - num_defaults))).iter() {
strs.push(ty_to_string(cx, *t))
}
format!("{}({}){}",
base,
if strs[0].starts_with("(") && strs[0].ends_with(",)") {
- strs[0][1 .. strs[0].len() - 2] // Remove '(' and ',)'
+ strs[0].index(&(1 .. (strs[0].len() - 2))) // Remove '(' and ',)'
} else if strs[0].starts_with("(") && strs[0].ends_with(")") {
- strs[0][1 .. strs[0].len() - 1] // Remove '(' and ')'
+ strs[0].index(&(1 .. (strs[0].len() - 1))) // Remove '(' and ')'
} else {
- strs[0][]
+ strs[0].index(&FullRange)
},
if &*strs[1] == "()" { String::new() } else { format!(" -> {}", strs[1]) })
} else if strs.len() > 0 {
pub fn ty_to_short_str<'tcx>(cx: &ctxt<'tcx>, typ: Ty<'tcx>) -> String {
let mut s = typ.repr(cx).to_string();
if s.len() >= 32u {
- s = s[0u..32u].to_string();
+ s = s.index(&(0u..32u)).to_string();
}
return s;
}
impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for OwnedSlice<T> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
- repr_vec(tcx, self[])
+ repr_vec(tcx, self.index(&FullRange))
}
}
// autoderef cannot convert the &[T] handler
impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for Vec<T> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
- repr_vec(tcx, self[])
+ repr_vec(tcx, self.index(&FullRange))
}
}
impl<'tcx> Repr<'tcx> for def::Def {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ty::TypeParameterDef<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
- format!("TypeParameterDef({}, {}, {}/{})",
+ format!("TypeParameterDef({:?}, {}, {:?}/{})",
self.def_id,
self.bounds.repr(tcx),
self.space,
fn repr(&self, tcx: &ctxt) -> String {
match *self {
ty::ReEarlyBound(id, space, index, name) => {
- format!("ReEarlyBound({}, {}, {}, {})",
+ format!("ReEarlyBound({}, {:?}, {}, {})",
id,
space,
index,
}
ty::ReLateBound(binder_id, ref bound_region) => {
- format!("ReLateBound({}, {})",
+ format!("ReLateBound({:?}, {})",
binder_id,
bound_region.repr(tcx))
}
ty::ReFree(ref fr) => fr.repr(tcx),
ty::ReScope(id) => {
- format!("ReScope({})", id)
+ format!("ReScope({:?})", id)
}
ty::ReStatic => {
}
ty::ReInfer(ReVar(ref vid)) => {
- format!("{}", vid)
+ format!("{:?}", vid)
}
ty::ReInfer(ReSkolemized(id, ref bound_region)) => {
Some(ast_map::NodeVariant(..)) |
Some(ast_map::NodeStructCtor(..)) => {
return format!(
- "{}:{}",
+ "{:?}:{}",
*self,
ty::item_path_str(tcx, *self))
}
_ => {}
}
}
- return format!("{}", *self)
+ return format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ast::ExplicitSelf_ {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ast::Visibility {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
}
}
+
impl<'tcx> Repr<'tcx> for ty::FnSig<'tcx> {
fn repr(&self, tcx: &ctxt<'tcx>) -> String {
format!("fn{} -> {}", self.inputs.repr(tcx), self.output.repr(tcx))
impl<'tcx> Repr<'tcx> for ty::BuiltinBound {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ast::Mutability {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ty::BorrowKind {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ty::IntVid {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", self)
+ format!("{:?}", self)
}
}
impl<'tcx> Repr<'tcx> for ty::FloatVid {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", self)
+ format!("{:?}", self)
}
}
impl<'tcx> Repr<'tcx> for ty::RegionVid {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", self)
+ format!("{:?}", self)
}
}
impl<'tcx> Repr<'tcx> for ty::TyVid {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", self)
+ format!("{:?}", self)
}
}
impl<'tcx> Repr<'tcx> for ty::IntVarValue {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ast::IntTy {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ast::UintTy {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ast::FloatTy {
fn repr(&self, _tcx: &ctxt) -> String {
- format!("{}", *self)
+ format!("{:?}", *self)
}
}
impl<'tcx> Repr<'tcx> for ParamTy {
fn repr(&self, tcx: &ctxt) -> String {
let ident = self.user_string(tcx);
- format!("{}/{}.{}", ident, self.space, self.idx)
+ format!("{}/{:?}.{}", ident, self.space, self.idx)
}
}
}
}
+#[old_impl_check]
impl<'tcx, S, H, K, V> Repr<'tcx> for HashMap<K,V,H>
where K : Hash<S> + Eq + Repr<'tcx>,
V : Repr<'tcx>,
pub fn actions_since_snapshot(&self,
snapshot: &Snapshot)
-> &[UndoLog<T,U>] {
- self.undo_log[snapshot.length..]
+ self.undo_log.index(&(snapshot.length..))
}
fn assert_open_snapshot(&self, snapshot: &Snapshot) {
args: &str, cwd: Option<&Path>,
paths: &[&Path]) -> ProcessOutput {
let ar = match *maybe_ar_prog {
- Some(ref ar) => ar[],
+ Some(ref ar) => ar.index(&FullRange),
None => "ar"
};
let mut cmd = Command::new(ar);
match cwd {
Some(p) => {
cmd.cwd(p);
- debug!("inside {}", p.display());
+ debug!("inside {:?}", p.display());
}
None => {}
}
if !o.status.success() {
handler.err(format!("{} failed with: {}",
cmd,
- o.status)[]);
+ o.status).index(&FullRange));
handler.note(format!("stdout ---\n{}",
str::from_utf8(o.output
- []).unwrap())
- []);
+ .index(&FullRange)).unwrap())
+ .index(&FullRange));
handler.note(format!("stderr ---\n{}",
str::from_utf8(o.error
- []).unwrap())
- []);
+ .index(&FullRange)).unwrap())
+ .index(&FullRange));
handler.abort_if_errors();
}
o
},
Err(e) => {
- handler.err(format!("could not exec `{}`: {}", ar[],
- e)[]);
+ handler.err(format!("could not exec `{}`: {}", ar.index(&FullRange),
+ e).index(&FullRange));
handler.abort_if_errors();
panic!("rustc::back::archive::run_ar() should not reach this point");
}
let unixlibname = format!("lib{}.a", name);
for path in search_paths.iter() {
- debug!("looking for {} inside {}", name, path.display());
- let test = path.join(oslibname[]);
+ debug!("looking for {} inside {:?}", name, path.display());
+ let test = path.join(oslibname.index(&FullRange));
if test.exists() { return test }
if oslibname != unixlibname {
- let test = path.join(unixlibname[]);
+ let test = path.join(unixlibname.index(&FullRange));
if test.exists() { return test }
}
}
handler.fatal(format!("could not find native static library `{}`, \
perhaps an -L flag is missing?",
- name)[]);
+ name).index(&FullRange));
}
impl<'a> Archive<'a> {
/// Lists all files in an archive
pub fn files(&self) -> Vec<String> {
let output = run_ar(self.handler, &self.maybe_ar_prog, "t", None, &[&self.dst]);
- let output = str::from_utf8(output.output[]).unwrap();
+ let output = str::from_utf8(output.output.index(&FullRange)).unwrap();
// use lines_any because windows delimits output with `\r\n` instead of
// just `\n`
output.lines_any().map(|s| s.to_string()).collect()
/// search in the relevant locations for a library named `name`.
pub fn add_native_library(&mut self, name: &str) -> io::IoResult<()> {
let location = find_library(name,
- self.archive.slib_prefix[],
- self.archive.slib_suffix[],
- self.archive.lib_search_paths[],
+ self.archive.slib_prefix.index(&FullRange),
+ self.archive.slib_suffix.index(&FullRange),
+ self.archive.lib_search_paths.index(&FullRange),
self.archive.handler);
self.add_archive(&location, name, |_| false)
}
// as simple comparison is not enough - there
// might be also an extra name suffix
let obj_start = format!("{}", name);
- let obj_start = obj_start[];
+ let obj_start = obj_start.index(&FullRange);
// Ignoring all bytecode files, no matter of
// name
let bc_ext = ".bytecode.deflate";
- self.add_archive(rlib, name[], |fname: &str| {
+ self.add_archive(rlib, name.index(&FullRange), |fname: &str| {
let skip_obj = lto && fname.starts_with(obj_start)
&& fname.ends_with(".o");
skip_obj || fname.ends_with(bc_ext) || fname == METADATA_FILENAME
// allow running `ar s file.a` to update symbols only.
if self.should_update_symbols {
run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
- "s", Some(self.work_dir.path()), args[]);
+ "s", Some(self.work_dir.path()), args.index(&FullRange));
}
return self.archive;
}
// Add the archive members seen so far, without updating the
// symbol table (`S`).
run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
- "cruS", Some(self.work_dir.path()), args[]);
+ "cruS", Some(self.work_dir.path()), args.index(&FullRange));
args.clear();
args.push(&abs_dst);
// necessary.
let flags = if self.should_update_symbols { "crus" } else { "cruS" };
run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
- flags, Some(self.work_dir.path()), args[]);
+ flags, Some(self.work_dir.path()), args.index(&FullRange));
self.archive
}
} else {
filename
};
- let new_filename = self.work_dir.path().join(filename[]);
+ let new_filename = self.work_dir.path().join(filename.index(&FullRange));
try!(fs::rename(file, &new_filename));
self.members.push(Path::new(filename));
}
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-
-#![allow(unknown_features)]
-#![feature(globs, phase, macro_rules, slicing_syntax)]
-#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
+#![feature(slicing_syntax)]
extern crate syntax;
extern crate serialize;
+#[macro_use] extern crate log;
pub mod abi;
pub mod archive;
l.map(|p| p.clone())
}).collect::<Vec<_>>();
- let rpaths = get_rpaths(config, libs[]);
- flags.push_all(rpaths_to_flags(rpaths[])[]);
+ let rpaths = get_rpaths(config, libs.index(&FullRange));
+ flags.push_all(rpaths_to_flags(rpaths.index(&FullRange)).index(&FullRange));
flags
}
fn rpaths_to_flags(rpaths: &[String]) -> Vec<String> {
let mut ret = Vec::new();
for rpath in rpaths.iter() {
- ret.push(format!("-Wl,-rpath,{}", (*rpath)[]));
+ ret.push(format!("-Wl,-rpath,{}", (*rpath).index(&FullRange)));
}
return ret;
}
F: FnOnce() -> Path,
G: FnMut(&Path) -> Result<Path, IoError>,
{
- debug!("output: {}", config.out_filename.display());
+ debug!("output: {:?}", config.out_filename.display());
debug!("libs:");
for libpath in libs.iter() {
- debug!(" {}", libpath.display());
+ debug!(" {:?}", libpath.display());
}
// Use relative paths to the libraries. Binaries can be moved
}
}
- log_rpaths("relative", rel_rpaths[]);
- log_rpaths("fallback", fallback_rpaths[]);
+ log_rpaths("relative", rel_rpaths.index(&FullRange));
+ log_rpaths("fallback", fallback_rpaths.index(&FullRange));
let mut rpaths = rel_rpaths;
- rpaths.push_all(fallback_rpaths[]);
+ rpaths.push_all(fallback_rpaths.index(&FullRange));
// Remove duplicates
- let rpaths = minimize_rpaths(rpaths[]);
+ let rpaths = minimize_rpaths(rpaths.index(&FullRange));
return rpaths;
}
let mut set = HashSet::new();
let mut minimized = Vec::new();
for rpath in rpaths.iter() {
- if set.insert(rpath[]) {
+ if set.insert(rpath.index(&FullRange)) {
minimized.push(rpath.clone());
}
}
if input.len() >= buffer_remaining {
copy_memory(
self.buffer.slice_mut(self.buffer_idx, size),
- input[..buffer_remaining]);
+ input.index(&(0..buffer_remaining)));
self.buffer_idx = 0;
func(&self.buffer);
i += buffer_remaining;
// While we have at least a full buffer size chunk's worth of data, process that data
// without copying it into the buffer
while input.len() - i >= size {
- func(input[i..i + size]);
+ func(input.index(&(i..(i + size))));
i += size;
}
let input_remaining = input.len() - i;
copy_memory(
self.buffer.slice_to_mut(input_remaining),
- input[i..]);
+ input.index(&(i..)));
self.buffer_idx += input_remaining;
}
fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
assert!(self.buffer_idx == 64);
self.buffer_idx = 0;
- return self.buffer[..64];
+ return self.buffer.index(&(0..64));
}
fn position(&self) -> uint { self.buffer_idx }
}
pub fn as_str<'a>(&'a self) -> &'a str {
- self.hash[]
+ self.hash.index(&FullRange)
}
pub fn calculate(metadata: &Vec<String>, krate: &ast::Crate) -> Svh {
}
impl fmt::Show for Svh {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ //NOTE(stage0): uncomment after snapshot
+ //write!(f, "Svh {{ {} }}", self.as_str())
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for Svh {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad(self.as_str())
}
fn macro_name(mac: &Mac) -> token::InternedString {
match &mac.node {
&MacInvocTT(ref path, ref _tts, ref _stx_ctxt) => {
- let s = path.segments[];
+ let s = path.segments.index(&FullRange);
assert_eq!(s.len(), 1);
content(s[0].identifier)
}
Some(val) => val,
None =>
handler.fatal((format!("Field {} in target specification is required", name))
- [])
+ .index(&FullRange))
}
};
macro_rules! key {
($key_name:ident) => ( {
let name = (stringify!($key_name)).replace("_", "-");
- obj.find(name[]).map(|o| o.as_string()
+ obj.find(name.index(&FullRange)).map(|o| o.as_string()
.map(|s| base.options.$key_name = s.to_string()));
} );
($key_name:ident, bool) => ( {
let name = (stringify!($key_name)).replace("_", "-");
- obj.find(name[]).map(|o| o.as_boolean().map(|s| base.options.$key_name = s));
+ obj.find(name.index(&FullRange))
+ .map(|o| o.as_boolean()
+ .map(|s| base.options.$key_name = s));
} );
($key_name:ident, list) => ( {
let name = (stringify!($key_name)).replace("_", "-");
- obj.find(name[]).map(|o| o.as_array()
+ obj.find(name.index(&FullRange)).map(|o| o.as_array()
.map(|v| base.options.$key_name = v.iter()
.map(|a| a.as_string().unwrap().to_string()).collect()
)
use serialize::json;
fn load_file(path: &Path) -> Result<Target, String> {
- let mut f = try!(File::open(path).map_err(|e| e.to_string()));
- let obj = try!(json::from_reader(&mut f).map_err(|e| e.to_string()));
+ let mut f = try!(File::open(path).map_err(|e| format!("{:?}", e)));
+ let obj = try!(json::from_reader(&mut f).map_err(|e| format!("{:?}", e)));
Ok(Target::from_json(obj))
}
$(
else if target == stringify!($name) {
let t = $name::target();
- debug!("Got builtin target: {}", t);
+ debug!("Got builtin target: {:?}", t);
return Ok(t);
}
)*
let target_path = os::getenv("RUST_TARGET_PATH").unwrap_or(String::new());
- let paths = os::split_paths(target_path[]);
+ let paths = os::split_paths(target_path.index(&FullRange));
// FIXME 16351: add a sane default search path?
for dir in paths.iter() {
}
}
- Err(format!("Could not find specification for target {}", target))
+ Err(format!("Could not find specification for target {:?}", target))
}
}
consume_span: Span,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume(consume_id={}, cmt={}, mode={})",
+ debug!("consume(consume_id={}, cmt={}, mode={:?})",
consume_id, cmt.repr(self.tcx()), mode);
self.consume_common(consume_id, consume_span, cmt, mode);
consume_pat: &ast::Pat,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume_pat(consume_pat={}, cmt={}, mode={})",
+ debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})",
consume_pat.repr(self.tcx()),
cmt.repr(self.tcx()),
mode);
bk: ty::BorrowKind,
loan_cause: euv::LoanCause)
{
- debug!("borrow(borrow_id={}, cmt={}, loan_region={}, \
- bk={}, loan_cause={})",
+ debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \
+ bk={:?}, loan_cause={:?})",
borrow_id, cmt.repr(self.tcx()), loan_region,
bk, loan_cause);
//! (Note that some loans can be *issued* without necessarily
//! taking effect yet.)
- debug!("check_for_conflicting_loans(scope={})", scope);
+ debug!("check_for_conflicting_loans(scope={:?})", scope);
let new_loan_indices = self.loans_generated_by(scope);
- debug!("new_loan_indices = {}", new_loan_indices);
+ debug!("new_loan_indices = {:?}", new_loan_indices);
self.each_issued_loan(scope, |issued_loan| {
for &new_loan_index in new_loan_indices.iter() {
new_loan.span,
format!("cannot borrow `{}`{} as mutable \
more than once at a time",
- nl, new_loan_msg)[])
+ nl, new_loan_msg).index(&FullRange))
}
(ty::UniqueImmBorrow, _) => {
new_loan.span,
format!("closure requires unique access to `{}` \
but {} is already borrowed{}",
- nl, ol_pronoun, old_loan_msg)[]);
+ nl, ol_pronoun, old_loan_msg).index(&FullRange));
}
(_, ty::UniqueImmBorrow) => {
new_loan.span,
format!("cannot borrow `{}`{} as {} because \
previous closure requires unique access",
- nl, new_loan_msg, new_loan.kind.to_user_str())[]);
+ nl, new_loan_msg, new_loan.kind.to_user_str()).index(&FullRange));
}
(_, _) => {
new_loan.kind.to_user_str(),
ol_pronoun,
old_loan.kind.to_user_str(),
- old_loan_msg)[]);
+ old_loan_msg).index(&FullRange));
}
}
self.bccx.span_note(
span,
format!("borrow occurs due to use of `{}` in closure",
- nl)[]);
+ nl).index(&FullRange));
}
_ => { }
}
self.bccx.span_note(
old_loan.span,
- format!("{}; {}", borrow_summary, rule_summary)[]);
+ format!("{}; {}", borrow_summary, rule_summary).index(&FullRange));
let old_loan_span = self.tcx().map.span(old_loan.kill_scope.node_id());
self.bccx.span_end_note(old_loan_span,
self.bccx.span_err(
span,
format!("cannot use `{}` because it was mutably borrowed",
- self.bccx.loan_path_to_string(copy_path)[])
- []);
+ self.bccx.loan_path_to_string(copy_path).index(&FullRange))
+ .index(&FullRange));
self.bccx.span_note(
loan_span,
format!("borrow of `{}` occurs here",
- self.bccx.loan_path_to_string(&*loan_path)[])
- []);
+ self.bccx.loan_path_to_string(&*loan_path).index(&FullRange))
+ .index(&FullRange));
}
}
}
let err_message = match move_kind {
move_data::Captured =>
format!("cannot move `{}` into closure because it is borrowed",
- self.bccx.loan_path_to_string(move_path)[]),
+ self.bccx.loan_path_to_string(move_path).index(&FullRange)),
move_data::Declared |
move_data::MoveExpr |
move_data::MovePat =>
format!("cannot move out of `{}` because it is borrowed",
- self.bccx.loan_path_to_string(move_path)[])
+ self.bccx.loan_path_to_string(move_path).index(&FullRange))
};
- self.bccx.span_err(span, err_message[]);
+ self.bccx.span_err(span, err_message.index(&FullRange));
self.bccx.span_note(
loan_span,
format!("borrow of `{}` occurs here",
- self.bccx.loan_path_to_string(&*loan_path)[])
- []);
+ self.bccx.loan_path_to_string(&*loan_path).index(&FullRange))
+ .index(&FullRange));
}
}
}
span: Span,
use_kind: MovedValueUseKind,
lp: &Rc<LoanPath<'tcx>>) {
- debug!("check_if_path_is_moved(id={}, use_kind={}, lp={})",
+ debug!("check_if_path_is_moved(id={}, use_kind={:?}, lp={})",
id, use_kind, lp.repr(self.bccx.tcx));
let base_lp = owned_ptr_base_path_rc(lp);
self.move_data.each_move_of(id, &base_lp, |the_move, moved_lp| {
self.bccx.span_err(
assignment_span,
format!("cannot assign to {}",
- self.bccx.cmt_to_string(&*assignee_cmt))[]);
+ self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange));
self.bccx.span_help(
self.tcx().map.span(upvar_id.closure_expr_id),
"consider changing this closure to take self by mutable reference");
assignment_span,
format!("cannot assign to {} {}",
assignee_cmt.mutbl.to_user_str(),
- self.bccx.cmt_to_string(&*assignee_cmt))[]);
+ self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange));
}
}
_ => match opt_loan_path(&assignee_cmt) {
format!("cannot assign to {} {} `{}`",
assignee_cmt.mutbl.to_user_str(),
self.bccx.cmt_to_string(&*assignee_cmt),
- self.bccx.loan_path_to_string(&*lp))[]);
+ self.bccx.loan_path_to_string(&*lp)).index(&FullRange));
}
None => {
self.bccx.span_err(
assignment_span,
format!("cannot assign to {} {}",
assignee_cmt.mutbl.to_user_str(),
- self.bccx.cmt_to_string(&*assignee_cmt))[]);
+ self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange));
}
}
}
self.bccx.span_err(
span,
format!("cannot assign to `{}` because it is borrowed",
- self.bccx.loan_path_to_string(loan_path))[]);
+ self.bccx.loan_path_to_string(loan_path)).index(&FullRange));
self.bccx.span_note(
loan.span,
format!("borrow of `{}` occurs here",
- self.bccx.loan_path_to_string(loan_path))[]);
+ self.bccx.loan_path_to_string(loan_path)).index(&FullRange));
}
}
//! necessary to add any restrictions at all to the final result.
//!
//! ```text
-//! RESTRICTIONS(*LV, LT, []) = [] // R-Deref-Freeze-Borrowed
+//! RESTRICTIONS(*LV, LT, []) = [] // R-Deref-Freeze-Borrowed
//! TYPE(LV) = &const Ty
//! ```
//!
// This represents the collection of all but one of the elements
// from an array at the path described by the move path index.
// Note that attached MovePathIndex should have mem_categorization
- // of InteriorElement (i.e. array dereference `[]`).
+ // of InteriorElement (i.e. array dereference `.index(&FullRange)`).
AllButOneFrom(MovePathIndex),
}
let attrs : &[ast::Attribute];
attrs = match tcx.map.find(id) {
Some(ast_map::NodeItem(ref item)) =>
- item.attrs[],
+ item.attrs.index(&FullRange),
Some(ast_map::NodeImplItem(&ast::MethodImplItem(ref m))) =>
- m.attrs[],
+ m.attrs.index(&FullRange),
Some(ast_map::NodeTraitItem(&ast::ProvidedMethod(ref m))) =>
- m.attrs[],
- _ => [][],
+ m.attrs.index(&FullRange),
+ _ => [].index(&FullRange),
};
let span_err =
for (i, mpi) in vec_rc.iter().enumerate() {
let render = |&:| this.path_loan_path(*mpi).user_string(tcx);
if span_err {
- tcx.sess.span_err(sp, format!("{}: `{}`", kind, render())[]);
+ tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
for (i, f) in vec_rc.iter().enumerate() {
let render = |&:| f.loan_path_user_string(this, tcx);
if span_err {
- tcx.sess.span_err(sp, format!("{}: `{}`", kind, render())[]);
+ tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange));
}
if print {
println!("id:{} {}[{}] `{}`", id, kind, i, render());
// First, filter out duplicates
moved.sort();
moved.dedup();
- debug!("fragments 1 moved: {}", path_lps(moved[]));
+ debug!("fragments 1 moved: {:?}", path_lps(moved.index(&FullRange)));
assigned.sort();
assigned.dedup();
- debug!("fragments 1 assigned: {}", path_lps(assigned[]));
+ debug!("fragments 1 assigned: {:?}", path_lps(assigned.index(&FullRange)));
// Second, build parents from the moved and assigned.
for m in moved.iter() {
parents.sort();
parents.dedup();
- debug!("fragments 2 parents: {}", path_lps(parents[]));
+ debug!("fragments 2 parents: {:?}", path_lps(parents.index(&FullRange)));
// Third, filter the moved and assigned fragments down to just the non-parents
- moved.retain(|f| non_member(*f, parents[]));
- debug!("fragments 3 moved: {}", path_lps(moved[]));
+ moved.retain(|f| non_member(*f, parents.index(&FullRange)));
+ debug!("fragments 3 moved: {:?}", path_lps(moved.index(&FullRange)));
- assigned.retain(|f| non_member(*f, parents[]));
- debug!("fragments 3 assigned: {}", path_lps(assigned[]));
+ assigned.retain(|f| non_member(*f, parents.index(&FullRange)));
+ debug!("fragments 3 assigned: {:?}", path_lps(assigned.index(&FullRange)));
// Fourth, build the leftover from the moved, assigned, and parents.
for m in moved.iter() {
unmoved.sort();
unmoved.dedup();
- debug!("fragments 4 unmoved: {}", frag_lps(unmoved[]));
+ debug!("fragments 4 unmoved: {:?}", frag_lps(unmoved.index(&FullRange)));
// Fifth, filter the leftover fragments down to its core.
unmoved.retain(|f| match *f {
AllButOneFrom(_) => true,
- Just(mpi) => non_member(mpi, parents[]) &&
- non_member(mpi, moved[]) &&
- non_member(mpi, assigned[])
+ Just(mpi) => non_member(mpi, parents.index(&FullRange)) &&
+ non_member(mpi, moved.index(&FullRange)) &&
+ non_member(mpi, assigned.index(&FullRange))
});
- debug!("fragments 5 unmoved: {}", frag_lps(unmoved[]));
+ debug!("fragments 5 unmoved: {:?}", frag_lps(unmoved.index(&FullRange)));
// Swap contents back in.
fragments.unmoved_fragments = unmoved;
}
ref sty_and_variant_info => {
- let msg = format!("type {} ({}) is not fragmentable",
+ let msg = format!("type {} ({:?}) is not fragmentable",
parent_ty.repr(tcx), sty_and_variant_info);
let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id));
- tcx.sess.opt_span_bug(opt_span, msg[])
+ tcx.sess.opt_span_bug(opt_span, msg.index(&FullRange))
}
}
}
cmt: mc::cmt<'tcx>,
mode: euv::MatchMode) {
let tcx = bccx.tcx;
- debug!("gather_match_variant(move_pat={}, cmt={}, mode={})",
+ debug!("gather_match_variant(move_pat={}, cmt={}, mode={:?})",
move_pat.id, cmt.repr(tcx), mode);
let opt_lp = opt_loan_path(&cmt);
_consume_span: Span,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume(consume_id={}, cmt={}, mode={})",
+ debug!("consume(consume_id={}, cmt={}, mode={:?})",
consume_id, cmt.repr(self.tcx()), mode);
match mode {
matched_pat: &ast::Pat,
cmt: mc::cmt<'tcx>,
mode: euv::MatchMode) {
- debug!("matched_pat(matched_pat={}, cmt={}, mode={})",
+ debug!("matched_pat(matched_pat={}, cmt={}, mode={:?})",
matched_pat.repr(self.tcx()),
cmt.repr(self.tcx()),
mode);
consume_pat: &ast::Pat,
cmt: mc::cmt<'tcx>,
mode: euv::ConsumeMode) {
- debug!("consume_pat(consume_pat={}, cmt={}, mode={})",
+ debug!("consume_pat(consume_pat={}, cmt={}, mode={:?})",
consume_pat.repr(self.tcx()),
cmt.repr(self.tcx()),
mode);
bk: ty::BorrowKind,
loan_cause: euv::LoanCause)
{
- debug!("borrow(borrow_id={}, cmt={}, loan_region={}, \
- bk={}, loan_cause={})",
+ debug!("borrow(borrow_id={}, cmt={}, loan_region={:?}, \
+ bk={:?}, loan_cause={:?})",
borrow_id, cmt.repr(self.tcx()), loan_region,
bk, loan_cause);
loan_region: ty::Region,
cause: euv::LoanCause) {
debug!("guarantee_valid(borrow_id={}, cmt={}, \
- req_mutbl={}, loan_region={})",
+ req_mutbl={:?}, loan_region={:?})",
borrow_id,
cmt.repr(self.tcx()),
req_kind,
self.bccx, borrow_span, cause,
cmt.clone(), loan_region);
- debug!("guarantee_valid(): restrictions={}", restr);
+ debug!("guarantee_valid(): restrictions={:?}", restr);
// Create the loan record (if needed).
let loan = match restr {
ty::ReInfer(..) => {
self.tcx().sess.span_bug(
cmt.span,
- format!("invalid borrow lifetime: {}",
- loan_region)[]);
+ format!("invalid borrow lifetime: {:?}",
+ loan_region).index(&FullRange));
}
};
- debug!("loan_scope = {}", loan_scope);
+ debug!("loan_scope = {:?}", loan_scope);
let borrow_scope = region::CodeExtent::from_node_id(borrow_id);
let gen_scope = self.compute_gen_scope(borrow_scope, loan_scope);
- debug!("gen_scope = {}", gen_scope);
+ debug!("gen_scope = {:?}", gen_scope);
let kill_scope = self.compute_kill_scope(loan_scope, &*loan_path);
- debug!("kill_scope = {}", kill_scope);
+ debug!("kill_scope = {:?}", kill_scope);
if req_kind == ty::MutBorrow {
self.mark_loan_path_as_mutated(&*loan_path);
bccx.span_err(
move_from.span,
format!("cannot move out of {}",
- bccx.cmt_to_string(&*move_from))[]);
+ bccx.cmt_to_string(&*move_from)).index(&FullRange));
}
mc::cat_downcast(ref b, _) |
move_from.span,
format!("cannot move out of type `{}`, \
which defines the `Drop` trait",
- b.ty.user_string(bccx.tcx))[]);
+ b.ty.user_string(bccx.tcx)).index(&FullRange));
},
_ => panic!("this path should not cause illegal move")
}
format!("to prevent the move, \
use `ref {0}` or `ref mut {0}` to capture value by \
reference",
- pat_name)[]);
+ pat_name).index(&FullRange));
} else {
bccx.span_note(move_to_span,
format!("and here (use `ref {0}` or `ref mut {0}`)",
- pat_name)[]);
+ pat_name).index(&FullRange));
}
}
check_loans::check_loans(this,
&loan_dfcx,
flowed_moves,
- all_loans[],
+ all_loans.index(&FullRange),
id,
decl,
body);
pub fn report(&self, err: BckError<'tcx>) {
self.span_err(
err.span,
- self.bckerr_to_string(&err)[]);
+ self.bckerr_to_string(&err).index(&FullRange));
self.note_and_explain_bckerr(err);
}
use_span,
format!("{} of possibly uninitialized variable: `{}`",
verb,
- self.loan_path_to_string(lp))[]);
+ self.loan_path_to_string(lp)).index(&FullRange));
(self.loan_path_to_string(moved_lp),
String::new())
}
format!("{} of {}moved value: `{}`",
verb,
msg,
- nl)[]);
+ nl).index(&FullRange));
(ol, moved_lp_msg)
}
};
}
r => {
self.tcx.sess.bug(format!("MoveExpr({}) maps to \
- {}, not Expr",
+ {:?}, not Expr",
the_move.id,
- r)[])
+ r).index(&FullRange))
}
};
let (suggestion, _) =
ol,
moved_lp_msg,
expr_ty.user_string(self.tcx),
- suggestion)[]);
+ suggestion).index(&FullRange));
}
move_data::MovePat => {
which is moved by default",
ol,
moved_lp_msg,
- pat_ty.user_string(self.tcx))[]);
+ pat_ty.user_string(self.tcx)).index(&FullRange));
self.tcx.sess.span_help(span,
"use `ref` to override");
}
}
r => {
self.tcx.sess.bug(format!("Captured({}) maps to \
- {}, not Expr",
+ {:?}, not Expr",
the_move.id,
- r)[])
+ r).index(&FullRange))
}
};
let (suggestion, help) =
ol,
moved_lp_msg,
expr_ty.user_string(self.tcx),
- suggestion)[]);
+ suggestion).index(&FullRange));
self.tcx.sess.span_help(expr_span, help);
}
}
self.tcx.sess.span_err(
span,
format!("re-assignment of immutable variable `{}`",
- self.loan_path_to_string(lp))[]);
+ self.loan_path_to_string(lp)).index(&FullRange));
self.tcx.sess.span_note(assign.span, "prior assignment occurs here");
}
self.tcx.sess.span_err(
span,
format!("{} in an aliasable location",
- prefix)[]);
+ prefix).index(&FullRange));
}
mc::AliasableClosure(id) => {
self.tcx.sess.span_err(span,
format!("{} in a captured outer \
- variable in an `Fn` closure", prefix)[]);
+ variable in an `Fn` closure", prefix).as_slice());
span_help!(self.tcx.sess, self.tcx.map.span(id),
"consider changing this closure to take self by mutable reference");
}
mc::AliasableStaticMut(..) => {
self.tcx.sess.span_err(
span,
- format!("{} in a static location", prefix)[]);
+ format!("{} in a static location", prefix).index(&FullRange));
}
mc::AliasableBorrowed => {
self.tcx.sess.span_err(
span,
- format!("{} in a `&` reference", prefix)[]);
+ format!("{} in a `&` reference", prefix).index(&FullRange));
}
}
note_and_explain_region(
self.tcx,
format!("{} would have to be valid for ",
- descr)[],
+ descr).index(&FullRange),
loan_scope,
"...");
note_and_explain_region(
self.tcx,
- format!("...but {} is only valid for ", descr)[],
+ format!("...but {} is only valid for ", descr).index(&FullRange),
ptr_scope,
"");
}
out.push('(');
self.append_loan_path_to_string(&**lp_base, out);
out.push_str(DOWNCAST_PRINTED_OPERATOR);
- out.push_str(ty::item_path_str(self.tcx, variant_def_id)[]);
+ out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange));
out.push(')');
}
}
mc::PositionalField(idx) => {
out.push('.');
- out.push_str(idx.to_string()[]);
+ out.push_str(idx.to_string().index(&FullRange));
}
}
}
out.push('(');
self.append_autoderefd_loan_path_to_string(&**lp_base, out);
out.push(':');
- out.push_str(ty::item_path_str(self.tcx, variant_def_id)[]);
+ out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange));
out.push(')');
}
impl<'tcx> Repr<'tcx> for Loan<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
- format!("Loan_{}({}, {}, {}-{}, {})",
+ format!("Loan_{}({}, {:?}, {:?}-{:?}, {})",
self.index,
self.loan_path.repr(tcx),
self.kind,
}
};
- debug!("move_path(lp={}, index={})",
+ debug!("move_path(lp={}, index={:?})",
lp.repr(tcx),
index);
lp: Rc<LoanPath<'tcx>>,
id: ast::NodeId,
kind: MoveKind) {
- debug!("add_move(lp={}, id={}, kind={})",
+ debug!("add_move(lp={}, id={}, kind={:?})",
lp.repr(tcx),
id,
kind);
};
if self.is_var_path(path_index) {
- debug!("add_assignment[var](lp={}, assignment={}, path_index={})",
+ debug!("add_assignment[var](lp={}, assignment={}, path_index={:?})",
lp.repr(tcx), self.var_assignments.borrow().len(), path_index);
self.var_assignments.borrow_mut().push(assignment);
} else {
- debug!("add_assignment[path](lp={}, path_index={})",
+ debug!("add_assignment[path](lp={}, path_index={:?})",
lp.repr(tcx), path_index);
self.path_assignments.borrow_mut().push(assignment);
impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> {
fn dataflow_for(&self, e: EntryOrExit, n: &Node<'a>) -> String {
let id = n.1.data.id;
- debug!("dataflow_for({}, id={}) {}", e, id, self.variants);
+ debug!("dataflow_for({:?}, id={}) {:?}", e, id, self.variants);
let mut sets = "".to_string();
let mut seen_one = false;
for &variant in self.variants.iter() {
if seen_one { sets.push_str(" "); } else { seen_one = true; }
sets.push_str(variant.short_name());
sets.push_str(": ");
- sets.push_str(self.dataflow_for_variant(e, n, variant)[]);
+ sets.push_str(self.dataflow_for_variant(e, n, variant).index(&FullRange));
}
sets
}
set.push_str(", ");
}
let loan_str = self.borrowck_ctxt.loan_path_to_string(&*lp);
- set.push_str(loan_str[]);
+ set.push_str(loan_str.index(&FullRange));
saw_some = true;
true
});
let dfcx = &self.analysis_data.loans;
let loan_index_to_path = |&mut: loan_index| {
let all_loans = &self.analysis_data.all_loans;
- all_loans[loan_index].loan_path()
+ let l: &borrowck::Loan = &all_loans[loan_index];
+ l.loan_path()
};
self.build_set(e, cfgidx, dfcx, loan_index_to_path)
}
let move_index_to_path = |&mut: move_index| {
let move_data = &self.analysis_data.move_data.move_data;
let moves = move_data.moves.borrow();
- let the_move = &(*moves)[move_index];
+ let the_move: &borrowck::move_data::Move = &(*moves)[move_index];
move_data.path_loan_path(the_move.path)
};
self.build_set(e, cfgidx, dfcx, move_index_to_path)
let assign_index_to_path = |&mut: assign_index| {
let move_data = &self.analysis_data.move_data.move_data;
let assignments = move_data.var_assignments.borrow();
- let assignment = &(*assignments)[assign_index];
+ let assignment: &borrowck::move_data::Assignment = &(*assignments)[assign_index];
move_data.path_loan_path(assignment.path)
};
self.build_set(e, cfgidx, dfcx, assign_index_to_path)
html_root_url = "http://doc.rust-lang.org/nightly/")]
#![allow(unknown_features)]
-#![feature(default_type_params, globs, macro_rules, phase, quote)]
+#![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
#![allow(non_camel_case_types)]
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate syntax;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate syntax;
+#[macro_use] extern crate log;
+#[macro_use] extern crate syntax;
// for "clarity", rename the graphviz crate to dot; graphviz within `borrowck`
// refers to the borrowck-specific graphviz adapter traits.
let outputs = build_output_filenames(input,
outdir,
output,
- krate.attrs[],
+ krate.attrs.index(&FullRange),
&sess);
- let id = link::find_crate_name(Some(&sess), krate.attrs[],
+ let id = link::find_crate_name(Some(&sess), krate.attrs.index(&FullRange),
input);
let expanded_crate
- = match phase_2_configure_and_expand(&sess, krate, id[],
+ = match phase_2_configure_and_expand(&sess, krate, id.index(&FullRange),
addl_plugins) {
None => return,
Some(k) => k
let mut forest = ast_map::Forest::new(expanded_crate);
let ast_map = assign_node_ids_and_map(&sess, &mut forest);
- write_out_deps(&sess, input, &outputs, id[]);
+ write_out_deps(&sess, input, &outputs, id.index(&FullRange));
if stop_after_phase_2(&sess) { return; }
let time_passes = sess.time_passes();
*sess.crate_types.borrow_mut() =
- collect_crate_types(sess, krate.attrs[]);
+ collect_crate_types(sess, krate.attrs.index(&FullRange));
*sess.crate_metadata.borrow_mut() =
- collect_crate_metadata(sess, krate.attrs[]);
+ collect_crate_metadata(sess, krate.attrs.index(&FullRange));
time(time_passes, "recursion limit", (), |_| {
middle::recursion_limit::update_recursion_limit(sess, &krate);
if cfg!(windows) {
_old_path = os::getenv("PATH").unwrap_or(_old_path);
let mut new_path = sess.host_filesearch(PathKind::All).get_dylib_search_paths();
- new_path.extend(os::split_paths(_old_path[]).into_iter());
- os::setenv("PATH", os::join_paths(new_path[]).unwrap());
+ new_path.extend(os::split_paths(_old_path.index(&FullRange)).into_iter());
+ os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap());
}
let cfg = syntax::ext::expand::ExpansionConfig {
crate_name: crate_name.to_string(),
time(sess.time_passes(), "LLVM passes", (), |_|
write::run_passes(sess,
trans,
- sess.opts.output_types[],
+ sess.opts.output_types.index(&FullRange),
outputs));
}
outputs: &OutputFilenames) {
let old_path = os::getenv("PATH").unwrap_or_else(||String::new());
let mut new_path = sess.host_filesearch(PathKind::All).get_tools_search_paths();
- new_path.extend(os::split_paths(old_path[]).into_iter());
- os::setenv("PATH", os::join_paths(new_path[]).unwrap());
+ new_path.extend(os::split_paths(old_path.index(&FullRange)).into_iter());
+ os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap());
time(sess.time_passes(), "linking", (), |_|
link::link_binary(sess,
trans,
outputs,
- trans.link.crate_name[]));
+ trans.link.crate_name.index(&FullRange)));
os::setenv("PATH", old_path);
}
// write Makefile-compatible dependency rules
let files: Vec<String> = sess.codemap().files.borrow()
.iter().filter(|fmap| fmap.is_real_file())
- .map(|fmap| escape_dep_filename(fmap.name[]))
+ .map(|fmap| escape_dep_filename(fmap.name.index(&FullRange)))
.collect();
let mut file = try!(io::File::create(&deps_filename));
for path in out_filenames.iter() {
Ok(()) => {}
Err(e) => {
sess.fatal(format!("error writing dependencies to `{}`: {}",
- deps_filename.display(), e)[]);
+ deps_filename.display(), e).index(&FullRange));
}
}
}
let res = !link::invalid_output_for_target(session, *crate_type);
if !res {
- session.warn(format!("dropping unsupported crate type `{}` \
+ session.warn(format!("dropping unsupported crate type `{:?}` \
for target `{}`",
- *crate_type, session.opts.target_triple)[]);
+ *crate_type, session.opts.target_triple).index(&FullRange));
}
res
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(default_type_params, globs, macro_rules, phase, quote)]
+#![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unboxed_closures)]
-#![feature(associated_types)]
extern crate arena;
extern crate flate;
extern crate rustc_typeck;
extern crate serialize;
extern crate "rustc_llvm" as llvm;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate syntax;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate syntax;
+#[macro_use] extern crate log;
+#[macro_use] extern crate syntax;
pub use syntax::diagnostic;
let descriptions = diagnostics::registry::Registry::new(&DIAGNOSTICS);
match matches.opt_str("explain") {
Some(ref code) => {
- match descriptions.find_description(code[]) {
+ match descriptions.find_description(code.index(&FullRange)) {
Some(ref description) => {
println!("{}", description);
}
None => {
- early_error(format!("no extended information for {}", code)[]);
+ early_error(format!("no extended information for {}", code).index(&FullRange));
}
}
return;
early_error("no input filename given");
}
1u => {
- let ifile = matches.free[0][];
+ let ifile = matches.free[0].index(&FullRange);
if ifile == "-" {
let contents = io::stdin().read_to_end().unwrap();
let src = String::from_utf8(contents).unwrap();
for lint in lints.into_iter() {
let name = lint.name_lower().replace("_", "-");
println!(" {} {:7.7} {}",
- padded(name[]), lint.default_level.as_str(), lint.desc);
+ padded(name.index(&FullRange)), lint.default_level.as_str(), lint.desc);
}
println!("\n");
};
let desc = to.into_iter().map(|x| x.as_str().replace("_", "-"))
.collect::<Vec<String>>().connect(", ");
println!(" {} {}",
- padded(name[]), desc);
+ padded(name.index(&FullRange)), desc);
}
println!("\n");
};
}
let matches =
- match getopts::getopts(args[], config::optgroups()[]) {
+ match getopts::getopts(args.index(&FullRange), config::optgroups().index(&FullRange)) {
Ok(m) => m,
Err(f_stable_attempt) => {
// redo option parsing, including unstable options this time,
cfg = cfg.stack_size(STACK_SIZE);
}
- match cfg.spawn(move || { std::io::stdio::set_stderr(box w); f() }).join() {
+ match cfg.scoped(move || { std::io::stdio::set_stderr(box w); f() }).join() {
Ok(()) => { /* fallthrough */ }
Err(value) => {
// Thread panicked without emitting a fatal diagnostic
"run with `RUST_BACKTRACE=1` for a backtrace".to_string(),
];
for note in xs.iter() {
- emitter.emit(None, note[], None, diagnostic::Note)
+ emitter.emit(None, note.index(&FullRange), None, diagnostic::Note)
}
match r.read_to_string() {
Err(e) => {
emitter.emit(None,
format!("failed to read internal \
- stderr: {}", e)[],
+ stderr: {}", e).index(&FullRange),
None,
diagnostic::Error)
}
try!(pp::word(&mut s.s,
ppaux::ty_to_string(
tcx,
- ty::expr_ty(tcx, expr))[]));
+ ty::expr_ty(tcx, expr)).index(&FullRange)));
s.pclose()
}
_ => Ok(())
ItemViaNode(node_id) =>
NodesMatchingDirect(Some(node_id).into_iter()),
ItemViaPath(ref parts) =>
- NodesMatchingSuffix(map.nodes_matching_suffix(parts[])),
+ NodesMatchingSuffix(map.nodes_matching_suffix(parts.index(&FullRange))),
}
}
user_option,
self.reconstructed_input(),
is_wrong_because);
- sess.fatal(message[])
+ sess.fatal(message.index(&FullRange))
};
let mut saw_node = ast::DUMMY_NODE_ID;
let is_expanded = needs_expansion(&ppm);
let compute_ast_map = needs_ast_map(&ppm, &opt_uii);
let krate = if compute_ast_map {
- match driver::phase_2_configure_and_expand(&sess, krate, id[], None) {
+ match driver::phase_2_configure_and_expand(&sess, krate, id.index(&FullRange), None) {
None => return,
Some(k) => k
}
};
let src_name = driver::source_name(input);
- let src = sess.codemap().get_filemap(src_name[])
+ let src = sess.codemap().get_filemap(src_name.index(&FullRange))
.src.as_bytes().to_vec();
let mut rdr = MemReader::new(src);
(PpmSource(s), None) =>
s.call_with_pp_support(
sess, ast_map, &arenas, id, out, |annotation, out| {
- debug!("pretty printing source code {}", s);
+ debug!("pretty printing source code {:?}", s);
let sess = annotation.sess();
pprust::print_crate(sess.codemap(),
sess.diagnostic(),
(PpmSource(s), Some(uii)) =>
s.call_with_pp_support(
sess, ast_map, &arenas, id, (out,uii), |annotation, (out,uii)| {
- debug!("pretty printing source code {}", s);
+ debug!("pretty printing source code {:?}", s);
let sess = annotation.sess();
let ast_map = annotation.ast_map()
.expect("--pretty missing ast_map");
}),
(PpmFlowGraph, opt_uii) => {
- debug!("pretty printing flow graph for {}", opt_uii);
+ debug!("pretty printing flow graph for {:?}", opt_uii);
let uii = opt_uii.unwrap_or_else(|| {
sess.fatal(format!("`pretty flowgraph=..` needs NodeId (int) or
- unique path suffix (b::c::d)")[])
+ unique path suffix (b::c::d)").index(&FullRange))
});
let ast_map = ast_map.expect("--pretty flowgraph missing ast_map");
let node = ast_map.find(nodeid).unwrap_or_else(|| {
sess.fatal(format!("--pretty flowgraph couldn't find id: {}",
- nodeid)[])
+ nodeid).index(&FullRange))
});
let code = blocks::Code::from_node(node);
}
None => {
let message = format!("--pretty=flowgraph needs \
- block, fn, or method; got {}",
+ block, fn, or method; got {:?}",
node);
// point to what was found, if there's an
// accessible span.
match ast_map.opt_span(nodeid) {
- Some(sp) => sess.span_fatal(sp, message[]),
- None => sess.fatal(message[])
+ Some(sp) => sess.span_fatal(sp, message.index(&FullRange)),
+ None => sess.fatal(message.index(&FullRange))
}
}
}
pub fn t_param(&self, space: subst::ParamSpace, index: u32) -> Ty<'tcx> {
let name = format!("T{}", index);
- ty::mk_param(self.infcx.tcx, space, index, token::intern(name[]))
+ ty::mk_param(self.infcx.tcx, space, index, token::intern(name.index(&FullRange)))
}
pub fn re_early_bound(&self,
self.ty_to_string(t_glb));
match self.glb().tys(t1, t2) {
Err(e) => {
- panic!("unexpected error computing LUB: {}", e)
+ panic!("unexpected error computing LUB: {:?}", e)
}
Ok(t) => {
self.assert_eq(t, t_glb);
let mut walker = uniq_ty.walk();
while let Some(t) = walker.next() {
- debug!("walked to {}", t);
+ debug!("walked to {:?}", t);
let (expected_ty, skip) = expected.pop().unwrap();
assert_eq!(t, expected_ty);
if skip { walker.skip_current_subtree(); }
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(globs)]
#![feature(link_args)]
-#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
extern crate libc;
self.resolve_error(sp,
format!("duplicate definition of {} `{}`",
namespace_error_to_string(duplicate_type),
- token::get_name(name))[]);
+ token::get_name(name)).index(&FullRange));
{
let r = child.span_for_namespace(ns);
for sp in r.iter() {
self.session.span_note(*sp,
format!("first definition of {} `{}` here",
namespace_error_to_string(duplicate_type),
- token::get_name(name))[]);
+ token::get_name(name)).index(&FullRange));
}
}
}
name: Name,
new_parent: &Rc<Module>) {
debug!("(building reduced graph for \
- external crate) building external def, priv {}",
+ external crate) building external def, priv {:?}",
vis);
let is_public = vis == ast::Public;
let modifiers = if is_public { PUBLIC } else { DefModifiers::empty() } | IMPORTABLE;
DefLocal(..) | DefPrimTy(..) | DefTyParam(..) |
DefUse(..) | DefUpvar(..) | DefRegion(..) |
DefTyParamBinder(..) | DefLabel(..) | DefSelfTy(..) => {
- panic!("didn't expect `{}`", def);
+ panic!("didn't expect `{:?}`", def);
}
}
}
debug!("(building import directive) building import \
directive: {}::{}",
self.names_to_string(module_.imports.borrow().last().unwrap()
- .module_path[]),
+ .module_path.index(&FullRange)),
token::get_name(target));
let mut import_resolutions = module_.import_resolutions
// public or private item, we will check the correct thing, dependent on how the import
// is used.
fn finalize_import(&mut self, id: ast::NodeId, span: Span) {
- debug!("finalizing import uses for {}",
+ debug!("finalizing import uses for {:?}",
self.session.codemap().span_to_snippet(span));
if !self.used_imports.contains(&(id, TypeNS)) &&
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(globs, phase, slicing_syntax)]
+#![feature(slicing_syntax)]
#![feature(rustc_diagnostic_macros)]
-#![feature(associated_types)]
-#![feature(old_orphan_check)]
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate syntax;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate syntax;
+#[macro_use] extern crate log;
+#[macro_use] extern crate syntax;
extern crate rustc;
use syntax::ast::{RegionTyParamBound, StructField};
use syntax::ast::{TraitRef, TraitTyParamBound};
use syntax::ast::{Ty, TyBool, TyChar, TyF32};
-use syntax::ast::{TyF64, TyFloat, TyI, TyI8, TyI16, TyI32, TyI64, TyInt, TyObjectSum};
+use syntax::ast::{TyF64, TyFloat, TyIs, TyI8, TyI16, TyI32, TyI64, TyInt, TyObjectSum};
use syntax::ast::{TyParam, TyParamBound, TyPath, TyPtr, TyPolyTraitRef, TyQPath};
-use syntax::ast::{TyRptr, TyStr, TyU, TyU8, TyU16, TyU32, TyU64, TyUint};
+use syntax::ast::{TyRptr, TyStr, TyUs, TyU8, TyU16, TyU32, TyU64, TyUint};
use syntax::ast::{TypeImplItem};
use syntax::ast;
use syntax::ast_map;
impl fmt::Show for Module {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}, kind: {}, {}",
+ write!(f, "{:?}, kind: {:?}, {}",
self.def_id,
self.kind,
if self.is_public { "public" } else { "private" } )
/// Records a type definition.
fn define_type(&self, def: Def, sp: Span, modifiers: DefModifiers) {
- debug!("defining type for def {} with modifiers {}", def, modifiers);
+ debug!("defining type for def {:?} with modifiers {:?}", def, modifiers);
// Merges the type with the existing type def or creates a new one.
let type_def = self.type_def.borrow().clone();
match type_def {
/// Records a value definition.
fn define_value(&self, def: Def, sp: Span, modifiers: DefModifiers) {
- debug!("defining value for def {} with modifiers {}", def, modifiers);
+ debug!("defining value for def {:?} with modifiers {:?}", def, modifiers);
*self.value_def.borrow_mut() = Some(ValueNsDef {
def: def,
value_span: Some(sp),
table.intern("char", TyChar);
table.intern("f32", TyFloat(TyF32));
table.intern("f64", TyFloat(TyF64));
- table.intern("int", TyInt(TyI));
+ table.intern("int", TyInt(TyIs));
+ table.intern("isize", TyInt(TyIs));
table.intern("i8", TyInt(TyI8));
table.intern("i16", TyInt(TyI16));
table.intern("i32", TyInt(TyI32));
table.intern("i64", TyInt(TyI64));
table.intern("str", TyStr);
- table.intern("uint", TyUint(TyU));
+ table.intern("uint", TyUint(TyUs));
+ table.intern("usize", TyUint(TyUs));
table.intern("u8", TyUint(TyU8));
table.intern("u16", TyUint(TyU16));
table.intern("u32", TyUint(TyU32));
let msg = format!("unresolved import `{}`{}",
self.import_path_to_string(
import_directive.module_path
- [],
+ .index(&FullRange),
import_directive.subclass),
help);
- self.resolve_error(span, msg[]);
+ self.resolve_error(span, msg.index(&FullRange));
}
Indeterminate => break, // Bail out. We'll come around next time.
Success(()) => () // Good. Continue.
.iter()
.map(|seg| seg.identifier.name)
.collect();
- self.names_to_string(names[])
+ self.names_to_string(names.index(&FullRange))
}
fn import_directive_subclass_to_string(&mut self,
let module_path = &import_directive.module_path;
debug!("(resolving import for module) resolving import `{}::...` in `{}`",
- self.names_to_string(module_path[]),
+ self.names_to_string(module_path.index(&FullRange)),
self.module_to_string(&*module_));
// First, resolve the module path for the directive, if necessary.
Some((self.graph_root.get_module(), LastMod(AllPublic)))
} else {
match self.resolve_module_path(module_.clone(),
- module_path[],
+ module_path.index(&FullRange),
DontUseLexicalScope,
import_directive.span,
ImportSearch) {
lp: LastPrivate)
-> ResolveResult<()> {
debug!("(resolving single import) resolving `{}` = `{}::{}` from \
- `{}` id {}, last private {}",
+ `{}` id {}, last private {:?}",
token::get_name(target),
self.module_to_string(&*containing_module),
token::get_name(source),
shadowable: _
}) => {
debug!("(resolving single import) found \
- import in ns {}", namespace);
+ import in ns {:?}", namespace);
let id = import_resolution.id(namespace);
// track used imports and extern crates as well
this.used_imports.insert((id, namespace));
match *result {
BoundResult(ref target_module, ref name_bindings) => {
- debug!("(resolving single import) found {} target: {}",
+ debug!("(resolving single import) found {:?} target: {:?}",
namespace_name,
name_bindings.def_for_namespace(namespace));
self.check_for_conflicting_import(
}
UnboundResult => { /* Continue. */ }
UnknownResult => {
- panic!("{} result should be known at this point", namespace_name);
+ panic!("{:?} result should be known at this point", namespace_name);
}
}
};
let is_public = import_directive.is_public;
let mut import_resolutions = module_.import_resolutions.borrow_mut();
- let dest_import_resolution = import_resolutions.entry(&name).get().unwrap_or_else(
+ let dest_import_resolution = import_resolutions.entry(name).get().unwrap_or_else(
|vacant_entry| {
// Create a new import resolution from this child.
vacant_entry.insert(ImportResolution::new(id, is_public))
ValueNS => "value",
},
token::get_name(name).get());
- self.session.span_err(import_span, msg[]);
+ self.session.span_err(import_span, msg.index(&FullRange));
}
Some(_) | None => {}
}
if !name_bindings.defined_in_namespace_with(namespace, IMPORTABLE) {
let msg = format!("`{}` is not directly importable",
token::get_name(name));
- self.session.span_err(import_span, msg[]);
+ self.session.span_err(import_span, msg.index(&FullRange));
}
}
crate in this module \
(maybe you meant `use {0}::*`?)",
token::get_name(name).get());
- self.session.span_err(import_span, msg[]);
+ self.session.span_err(import_span, msg.index(&FullRange));
}
Some(_) | None => {}
}
let msg = format!("import `{}` conflicts with value \
in this module",
token::get_name(name).get());
- self.session.span_err(import_span, msg[]);
+ self.session.span_err(import_span, msg.index(&FullRange));
if let Some(span) = value.value_span {
self.session.span_note(span,
"conflicting value here");
let msg = format!("import `{}` conflicts with type in \
this module",
token::get_name(name).get());
- self.session.span_err(import_span, msg[]);
+ self.session.span_err(import_span, msg.index(&FullRange));
if let Some(span) = ty.type_span {
self.session.span_note(span,
"note conflicting type here")
let msg = format!("inherent implementations \
are only allowed on types \
defined in the current module");
- self.session.span_err(span, msg[]);
+ self.session.span_err(span, msg.index(&FullRange));
self.session.span_note(import_span,
"import from other module here")
}
let msg = format!("import `{}` conflicts with existing \
submodule",
token::get_name(name).get());
- self.session.span_err(import_span, msg[]);
+ self.session.span_err(import_span, msg.index(&FullRange));
if let Some(span) = ty.type_span {
self.session.span_note(span,
"note conflicting module here")
.span_err(span,
format!("an external crate named `{}` has already \
been imported into this module",
- token::get_name(name).get())[]);
+ token::get_name(name).get()).index(&FullRange));
}
}
format!("the name `{}` conflicts with an external \
crate that has been imported into this \
module",
- token::get_name(name).get())[]);
+ token::get_name(name).get()).index(&FullRange));
}
}
let segment_name = token::get_name(name);
let module_name = self.module_to_string(&*search_module);
let mut span = span;
- let msg = if "???" == module_name[] {
+ let msg = if "???" == module_name.index(&FullRange) {
span.hi = span.lo + Pos::from_uint(segment_name.get().len());
match search_parent_externals(name,
match module_prefix_result {
Failed(None) => {
let mpath = self.names_to_string(module_path);
- let mpath = mpath[];
+ let mpath = mpath.index(&FullRange);
match mpath.rfind(':') {
Some(idx) => {
let msg = format!("Could not find `{}` in `{}`",
// idx +- 1 to account for the
// colons on either side
- mpath[idx + 1..],
- mpath[0..idx - 1]);
+ mpath.index(&((idx + 1)..)),
+ mpath.index(&(0..(idx - 1))));
return Failed(Some((span, msg)));
},
None => {
namespace: Namespace)
-> ResolveResult<(Target, bool)> {
debug!("(resolving item in lexical scope) resolving `{}` in \
- namespace {} in `{}`",
+ namespace {:?} in `{}`",
token::get_name(name),
namespace,
self.module_to_string(&*module_));
None => {
// Not found; continue.
debug!("(resolving item in lexical scope) found \
- import resolution, but not in namespace {}",
+ import resolution, but not in namespace {:?}",
namespace);
}
Some(target) => {
true) {
Failed(Some((span, msg))) =>
self.resolve_error(span, format!("failed to resolve. {}",
- msg)[]),
+ msg).index(&FullRange)),
Failed(None) => (), // Continue up the search chain.
Indeterminate => {
// We couldn't see through the higher scope because of an
match import_resolution.target_for_namespace(namespace) {
None => {
debug!("(resolving name in module) name found, \
- but not in namespace {}",
+ but not in namespace {:?}",
namespace);
}
Some(target) => {
} else {
let err = format!("unresolved import (maybe you meant `{}::*`?)",
sn);
- self.resolve_error((*imports)[index].span, err[]);
+ self.resolve_error((*imports)[index].span, err.index(&FullRange));
}
}
match def_like {
DlDef(d @ DefUpvar(..)) => {
self.session.span_bug(span,
- format!("unexpected {} in bindings", d)[])
+ format!("unexpected {:?} in bindings", d).index(&FullRange))
}
DlDef(d @ DefLocal(_)) => {
let node_id = d.def_id().node;
def = DefUpvar(node_id, function_id, last_proc_body_id);
let mut seen = self.freevars_seen.borrow_mut();
- let seen = match seen.entry(&function_id) {
+ let seen = match seen.entry(function_id) {
Occupied(v) => v.into_mut(),
Vacant(v) => v.insert(NodeSet::new()),
};
if seen.contains(&node_id) {
continue;
}
- match self.freevars.borrow_mut().entry(&function_id) {
+ match self.freevars.borrow_mut().entry(function_id) {
Occupied(v) => v.into_mut(),
Vacant(v) => v.insert(vec![]),
}.push(Freevar { def: prev_def, span: span });
for (i, rib) in ribs.iter().enumerate().rev() {
match rib.bindings.get(&name).cloned() {
Some(def_like) => {
- return self.upvarify(ribs[i + 1..], def_like, span);
+ return self.upvarify(ribs.index(&((i + 1)..)), def_like, span);
}
None => {
// Continue.
generics,
implemented_traits,
&**self_type,
- impl_items[]);
+ impl_items.index(&FullRange));
}
ItemTrait(_, ref generics, ref bounds, ref trait_items) => {
ItemStruct(ref struct_def, ref generics) => {
self.resolve_struct(item.id,
generics,
- struct_def.fields[]);
+ struct_def.fields.index(&FullRange));
}
ItemMod(ref module_) => {
parameter in this type \
parameter list",
token::get_name(
- name))[])
+ name)).index(&FullRange))
}
seen_bindings.insert(name);
};
let msg = format!("attempt to {} a nonexistent trait `{}`", usage_str, path_str);
- self.resolve_error(trait_reference.path.span, msg[]);
+ self.resolve_error(trait_reference.path.span, msg.index(&FullRange));
}
Some(def) => {
match def {
(DefTrait(_), _) => {
- debug!("(resolving trait) found trait def: {}", def);
+ debug!("(resolving trait) found trait def: {:?}", def);
self.record_def(trait_reference.ref_id, def);
}
(def, _) => {
self.resolve_error(trait_reference.path.span,
format!("`{}` is not a trait",
self.path_names_to_string(
- &trait_reference.path))[]);
+ &trait_reference.path)).index(&FullRange));
// If it's a typedef, give a note
if let DefTy(..) = def {
self.session.span_note(
trait_reference.path.span,
format!("`type` aliases cannot be used for traits")
- []);
+ .index(&FullRange));
}
}
}
self.resolve_error(span,
format!("method `{}` is not a member of trait `{}`",
token::get_name(name),
- path_str)[]);
+ path_str).index(&FullRange));
}
}
}
format!("variable `{}` from pattern #1 is \
not bound in pattern #{}",
token::get_name(key),
- i + 1)[]);
+ i + 1).index(&FullRange));
}
Some(binding_i) => {
if binding_0.binding_mode != binding_i.binding_mode {
format!("variable `{}` is bound with different \
mode in pattern #{} than in pattern #1",
token::get_name(key),
- i + 1)[]);
+ i + 1).index(&FullRange));
}
}
}
format!("variable `{}` from pattern {}{} is \
not bound in pattern {}1",
token::get_name(key),
- "#", i + 1, "#")[]);
+ "#", i + 1, "#").index(&FullRange));
}
}
}
None => {
match self.resolve_path(ty.id, path, TypeNS, true) {
Some(def) => {
- debug!("(resolving type) resolved `{}` to \
- type {}",
+ debug!("(resolving type) resolved `{:?}` to \
+ type {:?}",
token::get_ident(path.segments.last().unwrap() .identifier),
def);
result_def = Some(def);
None => {
let msg = format!("use of undeclared type name `{}`",
self.path_names_to_string(path));
- self.resolve_error(ty.span, msg[]);
+ self.resolve_error(ty.span, msg.index(&FullRange));
}
}
}
format!("declaration of `{}` shadows an enum \
variant or unit-like struct in \
scope",
- token::get_name(renamed))[]);
+ token::get_name(renamed)).index(&FullRange));
}
FoundConst(ref def, lp) if mode == RefutableMode => {
debug!("(resolving pattern) resolving `{}` to \
list",
token::get_ident(
ident))
- [])
+ .index(&FullRange))
} else if bindings_list.get(&renamed) ==
Some(&pat_id) {
// Then this is a duplicate variable in the
format!("identifier `{}` is bound \
more than once in the same \
pattern",
- token::get_ident(ident))[]);
+ token::get_ident(ident)).index(&FullRange));
}
// Else, not bound in the same pattern: do
// nothing.
self.resolve_error(path.span,
format!("`{}` is not an enum variant, struct or const",
token::get_ident(
- path.segments.last().unwrap().identifier))[]);
+ path.segments.last().unwrap().identifier)).as_slice());
}
None => {
self.resolve_error(path.span,
format!("unresolved enum variant, struct or const `{}`",
token::get_ident(
- path.segments.last().unwrap().identifier))[]);
+ path.segments.last().unwrap().identifier)).as_slice());
}
}
}
result => {
debug!("(resolving pattern) didn't find struct \
- def: {}", result);
+ def: {:?}", result);
let msg = format!("`{}` does not name a structure",
self.path_names_to_string(path));
- self.resolve_error(path.span, msg[]);
+ self.resolve_error(path.span, msg.index(&FullRange));
}
}
}
ValueNS) {
Success((target, _)) => {
debug!("(resolve bare identifier pattern) succeeded in \
- finding {} at {}",
+ finding {} at {:?}",
token::get_name(name),
target.bindings.value_def.borrow());
match *target.bindings.value_def.borrow() {
match err {
Some((span, msg)) => {
self.resolve_error(span, format!("failed to resolve: {}",
- msg)[]);
+ msg).index(&FullRange));
}
None => ()
}
let last_private;
let module = self.current_module.clone();
match self.resolve_module_path(module,
- module_path[],
+ module_path.index(&FullRange),
UseLexicalScope,
path.span,
PathSearch) {
};
self.resolve_error(span, format!("failed to resolve. {}",
- msg)[]);
+ msg).index(&FullRange));
return None;
}
Indeterminate => panic!("indeterminate unexpected"),
let containing_module;
let last_private;
match self.resolve_module_path_from_root(root_module,
- module_path[],
+ module_path.index(&FullRange),
0,
path.span,
PathSearch,
Some((span, msg)) => (span, msg),
None => {
let msg = format!("Use of undeclared module `::{}`",
- self.names_to_string(module_path[]));
+ self.names_to_string(module_path.index(&FullRange)));
(path.span, msg)
}
};
self.resolve_error(span, format!("failed to resolve. {}",
- msg)[]);
+ msg).index(&FullRange));
return None;
}
}
TypeNS => {
let name = ident.name;
- self.search_ribs(self.type_ribs[], name, span)
+ self.search_ribs(self.type_ribs.index(&FullRange), name, span)
}
};
match search_result {
Some(DlDef(def)) => {
debug!("(resolving path in local ribs) resolved `{}` to \
- local: {}",
+ local: {:?}",
token::get_ident(ident),
def);
return Some(def);
match err {
Some((span, msg)) =>
self.resolve_error(span, format!("failed to resolve. {}",
- msg)[]),
+ msg).index(&FullRange)),
None => ()
}
}
} else {
match this.resolve_module_path(root,
- name_path[],
+ name_path.index(&FullRange),
UseLexicalScope,
span,
PathSearch) {
let name_path = path.segments.iter().map(|seg| seg.identifier.name).collect::<Vec<_>>();
// Look for a method in the current self type's impl module.
- match get_module(self, path.span, name_path[]) {
+ match get_module(self, path.span, name_path.index(&FullRange)) {
Some(module) => match module.children.borrow().get(&name) {
Some(binding) => {
let p_str = self.path_names_to_string(&path);
Some(definition) => self.record_def(expr.id, definition),
result => {
debug!("(resolving expression) didn't find struct \
- def: {}", result);
+ def: {:?}", result);
let msg = format!("`{}` does not name a structure",
self.path_names_to_string(path));
- self.resolve_error(path.span, msg[]);
+ self.resolve_error(path.span, msg.index(&FullRange));
}
}
self.resolve_error(
expr.span,
format!("use of undeclared label `{}`",
- token::get_ident(label))[])
+ token::get_ident(label)).index(&FullRange))
}
Some(DlDef(def @ DefLabel(_))) => {
// Since this def is a label, it is never read.
}
fn record_def(&mut self, node_id: NodeId, (def, lp): (Def, LastPrivate)) {
- debug!("(recording def) recording {} for {}, last private {}",
+ debug!("(recording def) recording {:?} for {}, last private {:?}",
def, node_id, lp);
assert!(match lp {LastImport{..} => false, _ => true},
"Import should only be used for `use` directives");
self.last_private.insert(node_id, lp);
- match self.def_map.borrow_mut().entry(&node_id) {
+ match self.def_map.borrow_mut().entry(node_id) {
// Resolve appears to "resolve" the same ID multiple
// times, so here is a sanity check it at least comes to
// the same conclusion! - nmatsakis
Occupied(entry) => if def != *entry.get() {
self.session
- .bug(format!("node_id {} resolved first to {} and \
- then {}",
+ .bug(format!("node_id {} resolved first to {:?} and \
+ then {:?}",
node_id,
*entry.get(),
- def)[]);
+ def).index(&FullRange));
},
Vacant(entry) => { entry.insert(def); },
}
self.resolve_error(pat.span,
format!("cannot use `ref` binding mode \
with {}",
- descr)[]);
+ descr).index(&FullRange));
}
}
}
return "???".to_string();
}
self.names_to_string(names.into_iter().rev()
- .collect::<Vec<ast::Name>>()[])
+ .collect::<Vec<ast::Name>>().index(&FullRange))
}
#[allow(dead_code)] // useful for debugging
ns: Namespace) {
match namebindings.def_for_namespace(ns) {
Some(d) => {
- debug!("(computing exports) YES: export '{}' => {}",
+ debug!("(computing exports) YES: export '{}' => {:?}",
name, d.def_id());
exports.push(Export {
name: name,
});
}
d_opt => {
- debug!("(computing exports) NO: {}", d_opt);
+ debug!("(computing exports) NO: {:?}", d_opt);
}
}
}
attrs: &[ast::Attribute],
input: &Input) -> String {
let validate = |&: s: String, span: Option<Span>| {
- creader::validate_crate_name(sess, s[], span);
+ creader::validate_crate_name(sess, s.index(&FullRange), span);
s
};
let msg = format!("--crate-name and #[crate_name] are \
required to match, but `{}` != `{}`",
s, name);
- sess.span_err(attr.span, msg[]);
+ sess.span_err(attr.span, msg.index(&FullRange));
}
}
return validate(s.clone(), None);
crate_name: name,
crate_hash: Svh::calculate(&sess.opts.cg.metadata, krate),
};
- info!("{}", r);
+ info!("{:?}", r);
return r;
}
// to be independent of one another in the crate.
symbol_hasher.reset();
- symbol_hasher.input_str(link_meta.crate_name[]);
+ symbol_hasher.input_str(link_meta.crate_name.index(&FullRange));
symbol_hasher.input_str("-");
symbol_hasher.input_str(link_meta.crate_hash.as_str());
for meta in tcx.sess.crate_metadata.borrow().iter() {
- symbol_hasher.input_str(meta[]);
+ symbol_hasher.input_str(meta.index(&FullRange));
}
symbol_hasher.input_str("-");
- symbol_hasher.input_str(encoder::encoded_ty(tcx, t)[]);
+ symbol_hasher.input_str(encoder::encoded_ty(tcx, t).index(&FullRange));
// Prefix with 'h' so that it never blends into adjacent digits
let mut hash = String::from_str("h");
- hash.push_str(truncated_hash_result(symbol_hasher)[]);
+ hash.push_str(truncated_hash_result(symbol_hasher).index(&FullRange));
hash
}
let mut tstr = String::new();
for c in c.escape_unicode() { tstr.push(c) }
result.push('$');
- result.push_str(tstr[1..]);
+ result.push_str(tstr.index(&(1..)));
}
}
}
if result.len() > 0u &&
result.as_bytes()[0] != '_' as u8 &&
! (result.as_bytes()[0] as char).is_xid_start() {
- return format!("_{}", result[]);
+ return format!("_{}", result.index(&FullRange));
}
return result;
fn push(n: &mut String, s: &str) {
let sani = sanitize(s);
- n.push_str(format!("{}{}", sani.len(), sani)[]);
+ n.push_str(format!("{}{}", sani.len(), sani).index(&FullRange));
}
// First, connect each component with <len, name> pairs.
for e in path {
- push(&mut n, token::get_name(e.name()).get()[])
+ push(&mut n, token::get_name(e.name()).get().index(&FullRange))
}
match hash {
hash.push(EXTRA_CHARS.as_bytes()[extra2] as char);
hash.push(EXTRA_CHARS.as_bytes()[extra3] as char);
- exported_name(path, hash[])
+ exported_name(path, hash.index(&FullRange))
}
pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
t: Ty<'tcx>,
name: &str) -> String {
let s = ppaux::ty_to_string(ccx.tcx(), t);
- let path = [PathName(token::intern(s[])),
+ let path = [PathName(token::intern(s.index(&FullRange))),
gensym_name(name)];
let hash = get_symbol_hash(ccx, t);
- mangle(ast_map::Values(path.iter()), Some(hash[]))
+ mangle(ast_map::Values(path.iter()), Some(hash.index(&FullRange)))
}
pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String {
Err(e) => {
sess.err(format!("failed to remove {}: {}",
path.display(),
- e)[]);
+ e).index(&FullRange));
}
}
}
let mut out_filenames = Vec::new();
for &crate_type in sess.crate_types.borrow().iter() {
if invalid_output_for_target(sess, crate_type) {
- sess.bug(format!("invalid output type `{}` for target os `{}`",
- crate_type, sess.opts.target_triple)[]);
+ sess.bug(format!("invalid output type `{:?}` for target os `{}`",
+ crate_type, sess.opts.target_triple).index(&FullRange));
}
let out_file = link_binary_output(sess, trans, crate_type, outputs,
crate_name);
out_filename.with_filename(format!("lib{}.rlib", libname))
}
config::CrateTypeDylib => {
- let (prefix, suffix) = (sess.target.target.options.dll_prefix[],
- sess.target.target.options.dll_suffix[]);
+ let (prefix, suffix) = (sess.target.target.options.dll_prefix.index(&FullRange),
+ sess.target.target.options.dll_suffix.index(&FullRange));
out_filename.with_filename(format!("{}{}{}",
prefix,
libname,
out_filename.with_filename(format!("lib{}.a", libname))
}
config::CrateTypeExecutable => {
- let suffix = sess.target.target.options.exe_suffix[];
+ let suffix = sess.target.target.options.exe_suffix.index(&FullRange);
out_filename.with_filename(format!("{}{}", libname, suffix))
}
}
if !out_is_writeable {
sess.fatal(format!("output file {} is not writeable -- check its \
permissions.",
- out_filename.display())[]);
+ out_filename.display()).index(&FullRange));
}
else if !obj_is_writeable {
sess.fatal(format!("object file {} is not writeable -- check its \
permissions.",
- obj_filename.display())[]);
+ obj_filename.display()).index(&FullRange));
}
match crate_type {
for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() {
match kind {
cstore::NativeStatic => {
- ab.add_native_library(l[]).unwrap();
+ ab.add_native_library(l.index(&FullRange)).unwrap();
}
cstore::NativeFramework | cstore::NativeUnknown => {}
}
let tmpdir = TempDir::new("rustc").ok().expect("needs a temp dir");
let metadata = tmpdir.path().join(METADATA_FILENAME);
match fs::File::create(&metadata).write(trans.metadata
- []) {
+ .index(&FullRange)) {
Ok(..) => {}
Err(e) => {
sess.err(format!("failed to write {}: {}",
metadata.display(),
- e)[]);
+ e).index(&FullRange));
sess.abort_if_errors();
}
}
// extension to it. This is to work around a bug in LLDB that
// would cause it to crash if the name of a file in an archive
// was exactly 16 bytes.
- let bc_filename = obj_filename.with_extension(format!("{}.bc", i)[]);
+ let bc_filename = obj_filename.with_extension(format!("{}.bc", i).as_slice());
let bc_deflated_filename = obj_filename.with_extension(
- format!("{}.bytecode.deflate", i)[]);
+ format!("{}.bytecode.deflate", i).index(&FullRange));
let bc_data = match fs::File::open(&bc_filename).read_to_end() {
Ok(buffer) => buffer,
Err(e) => sess.fatal(format!("failed to read bytecode: {}",
- e)[])
+ e).index(&FullRange))
};
- let bc_data_deflated = match flate::deflate_bytes(bc_data[]) {
+ let bc_data_deflated = match flate::deflate_bytes(bc_data.index(&FullRange)) {
Some(compressed) => compressed,
None => sess.fatal(format!("failed to compress bytecode from {}",
- bc_filename.display())[])
+ bc_filename.display()).index(&FullRange))
};
let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) {
Ok(file) => file,
Err(e) => {
sess.fatal(format!("failed to create compressed bytecode \
- file: {}", e)[])
+ file: {}", e).index(&FullRange))
}
};
Ok(()) => {}
Err(e) => {
sess.err(format!("failed to write compressed bytecode: \
- {}", e)[]);
+ {}", e).index(&FullRange));
sess.abort_if_errors()
}
};
try! { writer.write(RLIB_BYTECODE_OBJECT_MAGIC) };
try! { writer.write_le_u32(1) };
try! { writer.write_le_u64(bc_data_deflated_size) };
- try! { writer.write(bc_data_deflated[]) };
+ try! { writer.write(bc_data_deflated.index(&FullRange)) };
let number_of_bytes_written_so_far =
RLIB_BYTECODE_OBJECT_MAGIC.len() + // magic id
let p = match *path {
Some(ref p) => p.clone(), None => {
sess.err(format!("could not find rlib for: `{}`",
- name)[]);
+ name).index(&FullRange));
continue
}
};
- ab.add_rlib(&p, name[], sess.lto()).unwrap();
+ ab.add_rlib(&p, name.index(&FullRange), sess.lto()).unwrap();
let native_libs = csearch::get_native_libraries(&sess.cstore, cnum);
all_native_libs.extend(native_libs.into_iter());
cstore::NativeUnknown => "library",
cstore::NativeFramework => "framework",
};
- sess.note(format!("{}: {}", name, *lib)[]);
+ sess.note(format!("{}: {}", name, *lib).index(&FullRange));
}
}
// The invocations of cc share some flags across platforms
let pname = get_cc_prog(sess);
- let mut cmd = Command::new(pname[]);
+ let mut cmd = Command::new(pname.index(&FullRange));
- cmd.args(sess.target.target.options.pre_link_args[]);
+ cmd.args(sess.target.target.options.pre_link_args.index(&FullRange));
link_args(&mut cmd, sess, dylib, tmpdir.path(),
trans, obj_filename, out_filename);
- cmd.args(sess.target.target.options.post_link_args[]);
+ cmd.args(sess.target.target.options.post_link_args.index(&FullRange));
if !sess.target.target.options.no_compiler_rt {
cmd.arg("-lcompiler-rt");
}
if !prog.status.success() {
sess.err(format!("linking with `{}` failed: {}",
pname,
- prog.status)[]);
- sess.note(format!("{}", &cmd)[]);
+ prog.status).index(&FullRange));
+ sess.note(format!("{}", &cmd).index(&FullRange));
let mut output = prog.error.clone();
- output.push_all(prog.output[]);
- sess.note(str::from_utf8(output[]).unwrap());
+ output.push_all(prog.output.index(&FullRange));
+ sess.note(str::from_utf8(output.index(&FullRange)).unwrap());
sess.abort_if_errors();
}
debug!("linker stderr:\n{}", String::from_utf8(prog.error).unwrap());
Err(e) => {
sess.err(format!("could not exec the linker `{}`: {}",
pname,
- e)[]);
+ e).index(&FullRange));
sess.abort_if_errors();
}
}
match Command::new("dsymutil").arg(out_filename).output() {
Ok(..) => {}
Err(e) => {
- sess.err(format!("failed to run dsymutil: {}", e)[]);
+ sess.err(format!("failed to run dsymutil: {}", e).index(&FullRange));
sess.abort_if_errors();
}
}
let mut v = b"-Wl,-force_load,".to_vec();
v.push_all(morestack.as_vec());
- cmd.arg(v[]);
+ cmd.arg(v.index(&FullRange));
} else {
cmd.args(&["-Wl,--whole-archive", "-lmorestack", "-Wl,--no-whole-archive"]);
}
if sess.opts.cg.rpath {
let mut v = "-Wl,-install_name,@rpath/".as_bytes().to_vec();
v.push_all(out_filename.filename().unwrap());
- cmd.arg(v[]);
+ cmd.arg(v.index(&FullRange));
}
} else {
cmd.arg("-shared");
// addl_lib_search_paths
if sess.opts.cg.rpath {
let sysroot = sess.sysroot();
- let target_triple = sess.opts.target_triple[];
+ let target_triple = sess.opts.target_triple.index(&FullRange);
let get_install_prefix_lib_path = |:| {
let install_prefix = option_env!("CFG_PREFIX").expect("CFG_PREFIX");
let tlib = filesearch::relative_target_lib_path(sysroot, target_triple);
get_install_prefix_lib_path: get_install_prefix_lib_path,
realpath: ::util::fs::realpath
};
- cmd.args(rpath::get_rpath_flags(rpath_config)[]);
+ cmd.args(rpath::get_rpath_flags(rpath_config).index(&FullRange));
}
// Finally add all the linker arguments provided on the command line along
// with any #[link_args] attributes found inside the crate
let empty = Vec::new();
- cmd.args(sess.opts.cg.link_args.as_ref().unwrap_or(&empty)[]);
- cmd.args(used_link_args[]);
+ cmd.args(sess.opts.cg.link_args.as_ref().unwrap_or(&empty).index(&FullRange));
+ cmd.args(used_link_args.index(&FullRange));
}
// # Native library linking
} else {
// -force_load is the OSX equivalent of --whole-archive, but it
// involves passing the full path to the library to link.
- let lib = archive::find_library(l[],
- sess.target.target.options.staticlib_prefix[],
- sess.target.target.options.staticlib_suffix[],
- search_path[],
+ let lib = archive::find_library(l.index(&FullRange),
+ sess.target.target.options.staticlib_prefix.as_slice(),
+ sess.target.target.options.staticlib_suffix.as_slice(),
+ search_path.index(&FullRange),
&sess.diagnostic().handler);
let mut v = b"-Wl,-force_load,".to_vec();
v.push_all(lib.as_vec());
- cmd.arg(v[]);
+ cmd.arg(v.index(&FullRange));
}
}
if takes_hints {
cmd.arg(format!("-l{}", l));
}
cstore::NativeFramework => {
- cmd.arg("-framework").arg(l[]);
+ cmd.arg("-framework").arg(l.index(&FullRange));
}
cstore::NativeStatic => unreachable!(),
}
// Converts a library file-stem into a cc -l argument
fn unlib<'a>(config: &config::Config, stem: &'a [u8]) -> &'a [u8] {
if stem.starts_with("lib".as_bytes()) && !config.target.options.is_like_windows {
- stem[3..]
+ stem.index(&(3..))
} else {
stem
}
// against the archive.
if sess.lto() {
let name = cratepath.filename_str().unwrap();
- let name = name[3..name.len() - 5]; // chop off lib/.rlib
+ let name = name.index(&(3..(name.len() - 5))); // chop off lib/.rlib
time(sess.time_passes(),
- format!("altering {}.rlib", name)[],
+ format!("altering {}.rlib", name).index(&FullRange),
(), |()| {
let dst = tmpdir.join(cratepath.filename().unwrap());
match fs::copy(&cratepath, &dst) {
sess.err(format!("failed to copy {} to {}: {}",
cratepath.display(),
dst.display(),
- e)[]);
+ e).index(&FullRange));
sess.abort_if_errors();
}
}
Err(e) => {
sess.err(format!("failed to chmod {} when preparing \
for LTO: {}", dst.display(),
- e)[]);
+ e).index(&FullRange));
sess.abort_if_errors();
}
}
maybe_ar_prog: sess.opts.cg.ar.clone()
};
let mut archive = Archive::open(config);
- archive.remove_file(format!("{}.o", name)[]);
+ archive.remove_file(format!("{}.o", name).index(&FullRange));
let files = archive.files();
- if files.iter().any(|s| s[].ends_with(".o")) {
+ if files.iter().any(|s| s.index(&FullRange).ends_with(".o")) {
cmd.arg(dst);
}
});
let mut v = "-l".as_bytes().to_vec();
v.push_all(unlib(&sess.target, cratepath.filestem().unwrap()));
- cmd.arg(v[]);
+ cmd.arg(v.index(&FullRange));
}
}
}
cstore::NativeFramework => {
cmd.arg("-framework");
- cmd.arg(lib[]);
+ cmd.arg(lib.index(&FullRange));
}
cstore::NativeStatic => {
sess.bug("statics shouldn't be propagated");
Some(p) => p,
None => {
sess.fatal(format!("could not find rlib for: `{}`",
- name)[]);
+ name).index(&FullRange));
}
};
let archive = ArchiveRO::open(&path).expect("wanted an rlib");
let file = path.filename_str().unwrap();
- let file = file[3..file.len() - 5]; // chop off lib/.rlib
+ let file = file.index(&(3..(file.len() - 5))); // chop off lib/.rlib
debug!("reading {}", file);
for i in iter::count(0u, 1) {
let bc_encoded = time(sess.time_passes(),
- format!("check for {}.{}.bytecode.deflate", name, i)[],
+ format!("check for {}.{}.bytecode.deflate", name, i).as_slice(),
(),
|_| {
archive.read(format!("{}.{}.bytecode.deflate",
- file, i)[])
+ file, i).index(&FullRange))
});
let bc_encoded = match bc_encoded {
Some(data) => data,
if i == 0 {
// No bitcode was found at all.
sess.fatal(format!("missing compressed bytecode in {}",
- path.display())[]);
+ path.display()).index(&FullRange));
}
// No more bitcode files to read.
break;
if version == 1 {
// The only version existing so far
let data_size = extract_compressed_bytecode_size_v1(bc_encoded);
- let compressed_data = bc_encoded[
+ let compressed_data = bc_encoded.index(&(
link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET..
- link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint];
+ (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint)));
match flate::inflate_bytes(compressed_data) {
Some(inflated) => inflated,
None => {
sess.fatal(format!("failed to decompress bc of `{}`",
- name)[])
+ name).index(&FullRange))
}
}
} else {
sess.fatal(format!("Unsupported bytecode format version {}",
- version)[])
+ version).index(&FullRange))
}
})
} else {
Some(bc) => bc,
None => {
sess.fatal(format!("failed to decompress bc of `{}`",
- name)[])
+ name).index(&FullRange))
}
}
})
let ptr = bc_decoded.as_slice().as_ptr();
debug!("linking {}, part {}", name, i);
time(sess.time_passes(),
- format!("ll link {}.{}", name, i)[],
+ format!("ll link {}.{}", name, i).index(&FullRange),
(),
|()| unsafe {
if !llvm::LLVMRustLinkInExternalBitcode(llmod,
bc_decoded.len() as libc::size_t) {
write::llvm_err(sess.diagnostic().handler(),
format!("failed to load bc of `{}`",
- name[]));
+ name.index(&FullRange)));
}
});
}
fn is_versioned_bytecode_format(bc: &[u8]) -> bool {
let magic_id_byte_count = link::RLIB_BYTECODE_OBJECT_MAGIC.len();
return bc.len() > magic_id_byte_count &&
- bc[..magic_id_byte_count] == link::RLIB_BYTECODE_OBJECT_MAGIC;
+ bc.index(&(0..magic_id_byte_count)) == link::RLIB_BYTECODE_OBJECT_MAGIC;
}
fn extract_bytecode_format_version(bc: &[u8]) -> u32 {
}
fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: uint) -> T {
- let byte_data = bytes[position_in_bytes..
- position_in_bytes + mem::size_of::<T>()];
+ let byte_data = bytes.index(&(position_in_bytes..
+ (position_in_bytes + mem::size_of::<T>())));
let data = unsafe {
*(byte_data.as_ptr() as *const T)
};
unsafe {
let cstr = llvm::LLVMRustGetLastError();
if cstr == ptr::null() {
- handler.fatal(msg[]);
+ handler.fatal(msg.index(&FullRange));
} else {
let err = ffi::c_str_to_bytes(&cstr);
let err = String::from_utf8_lossy(err.as_slice()).to_string();
libc::free(cstr as *mut _);
handler.fatal(format!("{}: {}",
- msg[],
- err[])[]);
+ msg.index(&FullRange),
+ err.index(&FullRange)).index(&FullRange));
}
}
}
match diag.code {
Some(ref code) => {
handler.emit_with_code(None,
- diag.msg[],
- code[],
+ diag.msg.index(&FullRange),
+ code.index(&FullRange),
diag.lvl);
},
None => {
handler.emit(None,
- diag.msg[],
+ diag.msg.index(&FullRange),
diag.lvl);
},
}
fn create_target_machine(sess: &Session) -> TargetMachineRef {
let reloc_model_arg = match sess.opts.cg.relocation_model {
- Some(ref s) => s[],
- None => sess.target.target.options.relocation_model[]
+ Some(ref s) => s.index(&FullRange),
+ None => sess.target.target.options.relocation_model.index(&FullRange)
};
let reloc_model = match reloc_model_arg {
"pic" => llvm::RelocPIC,
"default" => llvm::RelocDefault,
"dynamic-no-pic" => llvm::RelocDynamicNoPic,
_ => {
- sess.err(format!("{} is not a valid relocation mode",
+ sess.err(format!("{:?} is not a valid relocation mode",
sess.opts
.cg
- .relocation_model)[]);
+ .relocation_model).index(&FullRange));
sess.abort_if_errors();
unreachable!();
}
let fdata_sections = ffunction_sections;
let code_model_arg = match sess.opts.cg.code_model {
- Some(ref s) => s[],
- None => sess.target.target.options.code_model[]
+ Some(ref s) => s.index(&FullRange),
+ None => sess.target.target.options.code_model.index(&FullRange)
};
let code_model = match code_model_arg {
"medium" => llvm::CodeModelMedium,
"large" => llvm::CodeModelLarge,
_ => {
- sess.err(format!("{} is not a valid code model",
+ sess.err(format!("{:?} is not a valid code model",
sess.opts
.cg
- .code_model)[]);
+ .code_model).index(&FullRange));
sess.abort_if_errors();
unreachable!();
}
};
- let triple = sess.target.target.llvm_target[];
+ let triple = sess.target.target.llvm_target.index(&FullRange);
let tm = unsafe {
let triple = CString::from_slice(triple.as_bytes());
match cgcx.lto_ctxt {
Some((sess, _)) => {
sess.codemap().with_expn_info(ExpnId::from_llvm_cookie(cookie), |info| match info {
- Some(ei) => sess.span_err(ei.call_site, msg[]),
- None => sess.err(msg[]),
+ Some(ei) => sess.span_err(ei.call_site, msg.index(&FullRange)),
+ None => sess.err(msg.index(&FullRange)),
});
}
None => {
- cgcx.handler.err(msg[]);
+ cgcx.handler.err(msg.index(&FullRange));
cgcx.handler.note("build without -C codegen-units for more exact errors");
}
}
cgcx.handler.note(format!("optimization {} for {} at {}: {}",
opt.kind.describe(),
pass_name,
- if loc.is_empty() { "[unknown]" } else { loc[] },
- llvm::twine_to_string(opt.message))[]);
+ if loc.is_empty() { "[unknown]" } else { loc.as_slice() },
+ llvm::twine_to_string(opt.message)).as_slice());
}
}
for pass in config.passes.iter() {
let pass = CString::from_slice(pass.as_bytes());
if !llvm::LLVMRustAddPass(mpm, pass.as_ptr()) {
- cgcx.handler.warn(format!("unknown pass {}, ignoring",
+ cgcx.handler.warn(format!("unknown pass {:?}, ignoring",
pass).as_slice());
}
}
}
if config.emit_asm {
- let path = output_names.with_extension(format!("{}.s", name_extra)[]);
+ let path = output_names.with_extension(format!("{}.s", name_extra).index(&FullRange));
with_codegen(tm, llmod, config.no_builtins, |cpm| {
write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::AssemblyFileType);
});
}
if config.emit_obj {
- let path = output_names.with_extension(format!("{}.o", name_extra)[]);
+ let path = output_names.with_extension(format!("{}.o", name_extra).index(&FullRange));
with_codegen(tm, llmod, config.no_builtins, |cpm| {
write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::ObjectFileType);
});
// Process the work items, optionally using worker threads.
if sess.opts.cg.codegen_units == 1 {
- run_work_singlethreaded(sess, trans.reachable[], work_items);
+ run_work_singlethreaded(sess, trans.reachable.index(&FullRange), work_items);
} else {
run_work_multithreaded(sess, work_items, sess.opts.cg.codegen_units);
}
// 2) Multiple codegen units, with `-o some_name`. We have
// no good solution for this case, so warn the user.
sess.warn(format!("ignoring -o because multiple .{} files were produced",
- ext)[]);
+ ext).index(&FullRange));
} else {
// 3) Multiple codegen units, but no `-o some_name`. We
// just leave the `foo.0.x` files in place.
};
let pname = get_cc_prog(sess);
- let mut cmd = Command::new(pname[]);
+ let mut cmd = Command::new(pname.index(&FullRange));
- cmd.args(sess.target.target.options.pre_link_args[]);
+ cmd.args(sess.target.target.options.pre_link_args.index(&FullRange));
cmd.arg("-nostdlib");
for index in range(0, trans.modules.len()) {
- cmd.arg(crate_output.with_extension(format!("{}.o", index)[]));
+ cmd.arg(crate_output.with_extension(format!("{}.o", index).index(&FullRange)));
}
cmd.arg("-r")
.arg("-o")
.arg(windows_output_path.as_ref().unwrap_or(output_path));
- cmd.args(sess.target.target.options.post_link_args[]);
+ cmd.args(sess.target.target.options.post_link_args.index(&FullRange));
if (sess.opts.debugging_opts & config::PRINT_LINK_ARGS) != 0 {
println!("{}", &cmd);
Ok(status) => {
if !status.success() {
sess.err(format!("linking of {} with `{}` failed",
- output_path.display(), cmd)[]);
+ output_path.display(), cmd).index(&FullRange));
sess.abort_if_errors();
}
},
Err(e) => {
sess.err(format!("could not exec the linker `{}`: {}",
pname,
- e)[]);
+ e).index(&FullRange));
sess.abort_if_errors();
},
}
for i in range(0, trans.modules.len()) {
if modules_config.emit_obj {
let ext = format!("{}.o", i);
- remove(sess, &crate_output.with_extension(ext[]));
+ remove(sess, &crate_output.with_extension(ext.index(&FullRange)));
}
if modules_config.emit_bc && !keep_numbered_bitcode {
let ext = format!("{}.bc", i);
- remove(sess, &crate_output.with_extension(ext[]));
+ remove(sess, &crate_output.with_extension(ext.index(&FullRange)));
}
}
}
tx.take().unwrap().send(()).unwrap();
- }).detach();
+ });
}
let mut panicked = false;
pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) {
let pname = get_cc_prog(sess);
- let mut cmd = Command::new(pname[]);
+ let mut cmd = Command::new(pname.index(&FullRange));
cmd.arg("-c").arg("-o").arg(outputs.path(config::OutputTypeObject))
.arg(outputs.temp_path(config::OutputTypeAssembly));
if !prog.status.success() {
sess.err(format!("linking with `{}` failed: {}",
pname,
- prog.status)[]);
- sess.note(format!("{}", &cmd)[]);
+ prog.status).index(&FullRange));
+ sess.note(format!("{}", &cmd).index(&FullRange));
let mut note = prog.error.clone();
- note.push_all(prog.output[]);
- sess.note(str::from_utf8(note[]).unwrap());
+ note.push_all(prog.output.index(&FullRange));
+ sess.note(str::from_utf8(note.index(&FullRange)).unwrap());
sess.abort_if_errors();
}
},
Err(e) => {
sess.err(format!("could not exec the linker `{}`: {}",
pname,
- e)[]);
+ e).index(&FullRange));
sess.abort_if_errors();
}
}
if sess.print_llvm_passes() { add("-debug-pass=Structure"); }
for arg in sess.opts.cg.llvm_args.iter() {
- add((*arg)[]);
+ add((*arg).index(&FullRange));
}
}
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![allow(unknown_features)]
-#![feature(default_type_params, globs, macro_rules, phase, quote)]
+#![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
-#![feature(associated_types)]
extern crate arena;
extern crate flate;
extern crate serialize;
extern crate "rustc_llvm" as llvm;
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate syntax;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate syntax;
+#[macro_use] extern crate log;
+#[macro_use] extern crate syntax;
pub use rustc::session;
pub use rustc::metadata;
// dump info about all the external crates referenced from this crate
self.sess.cstore.iter_crate_data(|n, cmd| {
- self.fmt.external_crate_str(krate.span, cmd.name[], n);
+ self.fmt.external_crate_str(krate.span, cmd.name.index(&FullRange), n);
});
self.fmt.recorder.record("end_external_crates\n");
}
for &(ref span, ref qualname) in sub_paths.iter() {
self.fmt.sub_mod_ref_str(path.span,
*span,
- qualname[],
+ qualname.index(&FullRange),
self.cur_scope);
}
}
for &(ref span, ref qualname) in sub_paths.iter() {
self.fmt.sub_mod_ref_str(path.span,
*span,
- qualname[],
+ qualname.index(&FullRange),
self.cur_scope);
}
}
let (ref span, ref qualname) = sub_paths[len-2];
self.fmt.sub_type_ref_str(path.span,
*span,
- qualname[]);
+ qualname.index(&FullRange));
// write the other sub-paths
if len <= 2 {
return;
}
- let sub_paths = sub_paths[..len-2];
+ let sub_paths = sub_paths.index(&(0..(len-2)));
for &(ref span, ref qualname) in sub_paths.iter() {
self.fmt.sub_mod_ref_str(path.span,
*span,
- qualname[],
+ qualname.index(&FullRange),
self.cur_scope);
}
}
fn lookup_type_ref(&self, ref_id: NodeId) -> Option<DefId> {
if !self.analysis.ty_cx.def_map.borrow().contains_key(&ref_id) {
self.sess.bug(format!("def_map has no key for {} in lookup_type_ref",
- ref_id)[]);
+ ref_id).index(&FullRange));
}
let def = (*self.analysis.ty_cx.def_map.borrow())[ref_id];
match def {
let def_map = self.analysis.ty_cx.def_map.borrow();
if !def_map.contains_key(&ref_id) {
self.sess.span_bug(span, format!("def_map has no key for {} in lookup_def_kind",
- ref_id)[]);
+ ref_id).index(&FullRange));
}
let def = (*def_map)[ref_id];
match def {
def::DefUse(_) |
def::DefMethod(..) |
def::DefPrimTy(_) => {
- self.sess.span_bug(span, format!("lookup_def_kind for unexpected item: {}",
- def)[]);
+ self.sess.span_bug(span, format!("lookup_def_kind for unexpected item: {:?}",
+ def).index(&FullRange));
},
}
}
span_utils.span_for_last_ident(p.span),
id,
qualname,
- path_to_string(p)[],
- typ[]);
+ path_to_string(p).index(&FullRange),
+ typ.index(&FullRange));
}
self.collected_paths.clear();
}
match item.node {
ast::ItemImpl(_, _, _, _, ref ty, _) => {
let mut result = String::from_str("<");
- result.push_str(ty_to_string(&**ty)[]);
+ result.push_str(ty_to_string(&**ty).index(&FullRange));
match ty::trait_of_item(&self.analysis.ty_cx,
ast_util::local_def(method.id)) {
Some(def_id) => {
result.push_str(" as ");
result.push_str(
- ty::item_path_str(&self.analysis.ty_cx, def_id)[]);
+ ty::item_path_str(&self.analysis.ty_cx, def_id).as_slice());
},
None => {}
}
_ => {
self.sess.span_bug(method.span,
format!("Container {} for method {} not an impl?",
- impl_id.node, method.id)[]);
+ impl_id.node, method.id).index(&FullRange));
},
}
},
_ => {
self.sess.span_bug(method.span,
- format!("Container {} for method {} is not a node item {}",
+ format!("Container {} for method {} is not a node item {:?}",
impl_id.node,
method.id,
self.analysis.ty_cx.map.get(impl_id.node)
- )[]);
+ ).index(&FullRange));
},
},
None => match ty::trait_of_item(&self.analysis.ty_cx,
_ => {
self.sess.span_bug(method.span,
format!("Could not find container {} for method {}",
- def_id.node, method.id)[]);
+ def_id.node, method.id).index(&FullRange));
}
}
},
None => {
self.sess.span_bug(method.span,
format!("Could not find container for method {}",
- method.id)[]);
+ method.id).index(&FullRange));
},
},
};
qualname.push_str(get_ident(method.pe_ident()).get());
- let qualname = qualname[];
+ let qualname = qualname.index(&FullRange);
// record the decl for this def (if it has one)
let decl_id = ty::trait_item_of_item(&self.analysis.ty_cx,
Some(sub_span) => self.fmt.field_str(field.span,
Some(sub_span),
field.node.id,
- name.get()[],
- qualname[],
- typ[],
+ name.get().index(&FullRange),
+ qualname.index(&FullRange),
+ typ.index(&FullRange),
scope_id),
None => self.sess.span_bug(field.span,
format!("Could not find sub-span for field {}",
- qualname)[]),
+ qualname).index(&FullRange)),
}
},
_ => (),
self.fmt.typedef_str(full_span,
Some(*param_ss),
param.id,
- name[],
+ name.index(&FullRange),
"");
}
self.visit_generics(generics);
self.fmt.fn_str(item.span,
sub_span,
item.id,
- qualname[],
+ qualname.index(&FullRange),
self.cur_scope);
- self.process_formals(&decl.inputs, qualname[]);
+ self.process_formals(&decl.inputs, qualname.index(&FullRange));
// walk arg and return types
for arg in decl.inputs.iter() {
// walk the body
self.nest(item.id, |v| v.visit_block(&*body));
- self.process_generic_params(ty_params, item.span, qualname[], item.id);
+ self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id);
}
fn process_static(&mut self,
sub_span,
item.id,
get_ident(item.ident).get(),
- qualname[],
- value[],
- ty_to_string(&*typ)[],
+ qualname.index(&FullRange),
+ value.index(&FullRange),
+ ty_to_string(&*typ).index(&FullRange),
self.cur_scope);
// walk type and init value
sub_span,
item.id,
get_ident(item.ident).get(),
- qualname[],
+ qualname.index(&FullRange),
"",
- ty_to_string(&*typ)[],
+ ty_to_string(&*typ).index(&FullRange),
self.cur_scope);
// walk type and init value
sub_span,
item.id,
ctor_id,
- qualname[],
+ qualname.index(&FullRange),
self.cur_scope,
- val[]);
+ val.index(&FullRange));
// fields
for field in def.fields.iter() {
- self.process_struct_field_def(field, qualname[], item.id);
+ self.process_struct_field_def(field, qualname.index(&FullRange), item.id);
self.visit_ty(&*field.node.ty);
}
- self.process_generic_params(ty_params, item.span, qualname[], item.id);
+ self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id);
}
fn process_enum(&mut self,
Some(sub_span) => self.fmt.enum_str(item.span,
Some(sub_span),
item.id,
- enum_name[],
+ enum_name.index(&FullRange),
self.cur_scope,
- val[]),
+ val.index(&FullRange)),
None => self.sess.span_bug(item.span,
format!("Could not find subspan for enum {}",
- enum_name)[]),
+ enum_name).index(&FullRange)),
}
for variant in enum_definition.variants.iter() {
let name = get_ident(variant.node.name);
self.span.span_for_first_ident(variant.span),
variant.node.id,
name,
- qualname[],
- enum_name[],
- val[],
+ qualname.index(&FullRange),
+ enum_name.index(&FullRange),
+ val.index(&FullRange),
item.id);
for arg in args.iter() {
self.visit_ty(&*arg.ty);
self.span.span_for_first_ident(variant.span),
variant.node.id,
ctor_id,
- qualname[],
- enum_name[],
- val[],
+ qualname.index(&FullRange),
+ enum_name.index(&FullRange),
+ val.index(&FullRange),
item.id);
for field in struct_def.fields.iter() {
- self.process_struct_field_def(field, qualname[], variant.node.id);
+ self.process_struct_field_def(field, qualname.as_slice(), variant.node.id);
self.visit_ty(&*field.node.ty);
}
}
}
}
- self.process_generic_params(ty_params, item.span, enum_name[], item.id);
+ self.process_generic_params(ty_params, item.span, enum_name.index(&FullRange), item.id);
}
fn process_impl(&mut self,
self.fmt.trait_str(item.span,
sub_span,
item.id,
- qualname[],
+ qualname.index(&FullRange),
self.cur_scope,
- val[]);
+ val.index(&FullRange));
// super-traits
for super_bound in trait_refs.iter() {
}
// walk generics and methods
- self.process_generic_params(generics, item.span, qualname[], item.id);
+ self.process_generic_params(generics, item.span, qualname.index(&FullRange), item.id);
for method in methods.iter() {
self.visit_trait_item(method)
}
self.fmt.mod_str(item.span,
sub_span,
item.id,
- qualname[],
+ qualname.index(&FullRange),
self.cur_scope,
- filename[]);
+ filename.index(&FullRange));
self.nest(item.id, |v| visit::walk_mod(v, m));
}
let def_map = self.analysis.ty_cx.def_map.borrow();
if !def_map.contains_key(&id) {
self.sess.span_bug(span,
- format!("def_map has no key for {} in visit_expr", id)[]);
+ format!("def_map has no key for {} in visit_expr", id).as_slice());
}
let def = &(*def_map)[id];
let sub_span = self.span.span_for_last_ident(span);
self.cur_scope),
_ => self.sess.span_bug(span,
format!("Unexpected def kind while looking up path in '{}'",
- self.span.snippet(span))[]),
+ self.span.snippet(span)).index(&FullRange)),
}
// modules or types in the path prefix
match *def {
self.cur_scope);
// walk receiver and args
- visit::walk_exprs(self, args[]);
+ visit::walk_exprs(self, args.index(&FullRange));
}
fn process_pat(&mut self, p:&ast::Pat) {
None => {
self.sess.span_bug(p.span,
format!("Could not find struct_def for `{}`",
- self.span.snippet(p.span))[]);
+ self.span.snippet(p.span)).index(&FullRange));
}
};
for &Spanned { node: ref field, span } in fields.iter() {
self.fmt.typedef_str(item.span,
sub_span,
item.id,
- qualname[],
- value[]);
+ qualname.index(&FullRange),
+ value.index(&FullRange));
self.visit_ty(&**ty);
- self.process_generic_params(ty_params, item.span, qualname[], item.id);
+ self.process_generic_params(ty_params, item.span, qualname.as_slice(), item.id);
},
ast::ItemMac(_) => (),
_ => visit::walk_item(self, item),
None => {
self.sess.span_bug(method_type.span,
format!("Could not find trait for method {}",
- method_type.id)[]);
+ method_type.id).index(&FullRange));
},
};
qualname.push_str(get_ident(method_type.ident).get());
- let qualname = qualname[];
+ let qualname = qualname.index(&FullRange);
let sub_span = self.span.sub_span_after_keyword(method_type.span, keywords::Fn);
self.fmt.method_decl_str(method_type.span,
id,
cnum,
name,
- s[],
+ s.index(&FullRange),
self.cur_scope);
},
}
}
let mut id = String::from_str("$");
- id.push_str(ex.id.to_string()[]);
- self.process_formals(&decl.inputs, id[]);
+ id.push_str(ex.id.to_string().index(&FullRange));
+ self.process_formals(&decl.inputs, id.index(&FullRange));
// walk arg and return types
for arg in decl.inputs.iter() {
let def_map = self.analysis.ty_cx.def_map.borrow();
if !def_map.contains_key(&id) {
self.sess.span_bug(p.span,
- format!("def_map has no key for {} in visit_arm", id)[]);
+ format!("def_map has no key for {} in visit_arm",
+ id).index(&FullRange));
}
let def = &(*def_map)[id];
match *def {
self.fmt.variable_str(p.span,
Some(p.span),
id,
- path_to_string(p)[],
- value[],
+ path_to_string(p).index(&FullRange),
+ value.index(&FullRange),
"")
}
def::DefVariant(..) => {
// FIXME(nrc) what are these doing here?
def::DefStatic(_, _) => {}
def::DefConst(..) => {}
- _ => error!("unexpected definition kind when processing collected paths: {}", *def)
+ _ => error!("unexpected definition kind when processing collected paths: {:?}",
+ *def)
}
}
for &(id, span, ref path, ref_kind) in paths_to_process.iter() {
self.fmt.variable_str(p.span,
sub_span,
id,
- path_to_string(p)[],
- value[],
- typ[]);
+ path_to_string(p).index(&FullRange),
+ value.index(&FullRange),
+ typ.index(&FullRange));
}
self.collected_paths.clear();
}
assert!(analysis.glob_map.is_some());
- let cratename = match attr::find_crate_name(krate.attrs[]) {
+ let cratename = match attr::find_crate_name(krate.attrs.index(&FullRange)) {
Some(name) => name.get().to_string(),
None => {
info!("Could not find crate name, using 'unknown_crate'");
match fs::mkdir_recursive(&root_path, io::USER_RWX) {
Err(e) => sess.err(format!("Could not create directory {}: {}",
- root_path.display(), e)[]),
+ root_path.display(), e).index(&FullRange)),
_ => (),
}
Ok(f) => box f,
Err(e) => {
let disp = root_path.display();
- sess.fatal(format!("Could not open {}: {}", disp, e)[]);
+ sess.fatal(format!("Could not open {}: {}", disp, e).index(&FullRange));
}
};
root_path.pop();
cur_scope: 0
};
- visitor.dump_crate_info(cratename[], krate);
+ visitor.dump_crate_info(cratename.index(&FullRange), krate);
visit::walk_crate(&mut visitor, krate);
}
assert!(self.dump_spans);
let result = format!("span,kind,{},{},text,\"{}\"\n",
kind, su.extent_str(span), escape(su.snippet(span)));
- self.record(result[]);
+ self.record(result.index(&FullRange));
}
}
if values.len() != fields.len() {
self.span.sess.span_bug(span, format!(
"Mismatch between length of fields for '{}', expected '{}', found '{}'",
- kind, fields.len(), values.len())[]);
+ kind, fields.len(), values.len()).index(&FullRange));
}
let values = values.iter().map(|s| {
// Never take more than 1020 chars
if s.len() > 1020 {
- s[..1020]
+ s.index(&(0..1020))
} else {
- s[]
+ s.index(&FullRange)
}
});
}
)));
Some(strs.fold(String::new(), |mut s, ss| {
- s.push_str(ss[]);
+ s.push_str(ss.index(&FullRange));
s
}))
}
if needs_span {
self.span.sess.span_bug(span, format!(
"Called record_without_span for '{}' which does requires a span",
- label)[]);
+ label).index(&FullRange));
}
assert!(!dump_spans);
};
let mut result = String::from_str(label);
- result.push_str(values_str[]);
+ result.push_str(values_str.index(&FullRange));
result.push_str("\n");
- self.recorder.record(result[]);
+ self.recorder.record(result.index(&FullRange));
}
pub fn record_with_span(&mut self,
if !needs_span {
self.span.sess.span_bug(span,
format!("Called record_with_span for '{}' \
- which does not require a span", label)[]);
+ which does not require a span", label).as_slice());
}
let values_str = match self.make_values_str(label, fields, values, span) {
None => return,
};
let result = format!("{},{}{}\n", label, self.span.extent_str(sub_span), values_str);
- self.recorder.record(result[]);
+ self.recorder.record(result.index(&FullRange));
}
pub fn check_and_record(&mut self,
// variable def's node id
let mut qualname = String::from_str(name);
qualname.push_str("$");
- qualname.push_str(id.to_string()[]);
+ qualname.push_str(id.to_string().index(&FullRange));
self.check_and_record(Variable,
span,
sub_span,
let loc = self.sess.codemap().lookup_char_pos(span.lo);
self.sess.span_bug(span,
format!("Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}",
- self.snippet(span), loc.file.name, loc.line)[]);
+ self.snippet(span), loc.file.name, loc.line).index(&FullRange));
}
if result.is_none() && prev.tok.is_ident() && bracket_count == 0 {
return self.make_sub_span(span, Some(prev.sp));
let loc = self.sess.codemap().lookup_char_pos(span.lo);
self.sess.span_bug(span, format!(
"Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}",
- self.snippet(span), loc.file.name, loc.line)[]);
+ self.snippet(span), loc.file.name, loc.line).index(&FullRange));
}
return result
}
let _indenter = indenter();
m.iter().filter_map(|br| {
- e(br.pats[]).map(|pats| {
+ e(br.pats.index(&FullRange)).map(|pats| {
let this = br.pats[col];
let mut bound_ptrs = br.bound_ptrs.clone();
match this.node {
// Collect all of the matches that can match against anything.
enter_match(bcx, dm, m, col, val, |pats| {
if pat_is_binding_or_wild(dm, &*pats[col]) {
- let mut r = pats[..col].to_vec();
- r.push_all(pats[col + 1..]);
+ let mut r = pats.index(&(0..col)).to_vec();
+ r.push_all(pats.index(&((col + 1)..)));
Some(r)
} else {
None
variant_size: uint,
val: ValueRef)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
- debug!("enter_opt(bcx={}, m={}, opt={}, col={}, val={})",
+ debug!("enter_opt(bcx={}, m={}, opt={:?}, col={}, val={})",
bcx.to_str(),
m.repr(bcx.tcx()),
*opt,
param_env: param_env,
};
enter_match(bcx, dm, m, col, val, |pats|
- check_match::specialize(&mcx, pats[], &ctor, col, variant_size)
+ check_match::specialize(&mcx, pats.index(&FullRange), &ctor, col, variant_size)
)
}
let did = langcall(cx,
None,
format!("comparison of `{}`",
- cx.ty_to_string(rhs_t))[],
+ cx.ty_to_string(rhs_t)).index(&FullRange),
StrEqFnLangItem);
callee::trans_lang_call(cx, did, &[lhs, rhs], None)
}
if has_nested_bindings(m, col) {
let expanded = expand_nested_bindings(bcx, m, col, val);
compile_submatch_continue(bcx,
- expanded[],
+ expanded.index(&FullRange),
vals,
chk,
col,
bcx = compile_guard(bcx,
&**guard_expr,
m[0].data,
- m[1..m.len()],
+ m.index(&(1..m.len())),
vals,
chk,
has_genuine_default);
let tcx = bcx.tcx();
let dm = &tcx.def_map;
- let mut vals_left = vals[0u..col].to_vec();
- vals_left.push_all(vals[col + 1u..]);
+ let mut vals_left = vals.index(&(0u..col)).to_vec();
+ vals_left.push_all(vals.index(&((col + 1u)..)));
let ccx = bcx.fcx.ccx;
// Find a real id (we're adding placeholder wildcard patterns, but
field_vals.len())
);
let mut vals = field_vals;
- vals.push_all(vals_left[]);
- compile_submatch(bcx, pats[], vals[], chk, has_genuine_default);
+ vals.push_all(vals_left.as_slice());
+ compile_submatch(bcx, pats.as_slice(), vals.as_slice(), chk, has_genuine_default);
return;
}
_ => ()
// Decide what kind of branch we need
let opts = get_branches(bcx, m, col);
- debug!("options={}", opts);
+ debug!("options={:?}", opts);
let mut kind = NoBranch;
let mut test_val = val;
debug!("test_val={}", bcx.val_to_string(test_val));
}
let opt_ms = enter_opt(opt_cx, pat_id, dm, m, opt, col, size, val);
let mut opt_vals = unpacked;
- opt_vals.push_all(vals_left[]);
+ opt_vals.push_all(vals_left.index(&FullRange));
compile_submatch(opt_cx,
- opt_ms[],
- opt_vals[],
+ opt_ms.index(&FullRange),
+ opt_vals.index(&FullRange),
branch_chk.as_ref().unwrap_or(chk),
has_genuine_default);
}
}
_ => {
compile_submatch(else_cx,
- defaults[],
- vals_left[],
+ defaults.index(&FullRange),
+ vals_left.index(&FullRange),
chk,
has_genuine_default);
}
"__llmatch");
trmode = TrByCopy(alloca_no_lifetime(bcx,
llvariable_ty,
- bcx.ident(ident)[]));
+ bcx.ident(ident).index(&FullRange)));
}
ast::BindByValue(_) => {
// in this case, the final type of the variable will be T,
// above
llmatch = alloca_no_lifetime(bcx,
llvariable_ty.ptr_to(),
- bcx.ident(ident)[]);
+ bcx.ident(ident).index(&FullRange));
trmode = TrByMove;
}
ast::BindByRef(_) => {
llmatch = alloca_no_lifetime(bcx,
llvariable_ty,
- bcx.ident(ident)[]);
+ bcx.ident(ident).index(&FullRange));
trmode = TrByRef;
}
};
&& arm.pats.last().unwrap().node == ast::PatWild(ast::PatWildSingle)
});
- compile_submatch(bcx, matches[], &[discr_datum.val], &chk, has_default);
+ compile_submatch(bcx, matches.index(&FullRange), &[discr_datum.val], &chk, has_default);
let mut arm_cxs = Vec::new();
for arm_data in arm_datas.iter() {
arm_cxs.push(bcx);
}
- bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs[]);
+ bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs.index(&FullRange));
return bcx;
}
let var_ty = node_id_type(bcx, p_id);
// Allocate memory on stack for the binding.
- let llval = alloc_ty(bcx, var_ty, bcx.ident(*ident)[]);
+ let llval = alloc_ty(bcx, var_ty, bcx.ident(*ident).index(&FullRange));
// Subtle: be sure that we *populate* the memory *before*
// we schedule the cleanup.
if bcx.sess().asm_comments() {
add_comment(bcx, format!("bind_irrefutable_pat(pat={})",
- pat.repr(bcx.tcx()))[]);
+ pat.repr(bcx.tcx())).index(&FullRange));
}
let _indenter = indenter();
}
let repr = Rc::new(represent_type_uncached(cx, t));
- debug!("Represented as: {}", repr);
+ debug!("Represented as: {:?}", repr);
cx.adt_reprs().borrow_mut().insert(t, repr.clone());
repr
}
t: Ty<'tcx>) -> Repr<'tcx> {
match t.sty {
ty::ty_tup(ref elems) => {
- Univariant(mk_struct(cx, elems[], false, t), false)
+ Univariant(mk_struct(cx, elems.index(&FullRange), false, t), false)
}
ty::ty_struct(def_id, substs) => {
let fields = ty::lookup_struct_fields(cx.tcx(), def_id);
let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag();
if dtor { ftys.push(cx.tcx().types.bool); }
- Univariant(mk_struct(cx, ftys[], packed, t), dtor)
+ Univariant(mk_struct(cx, ftys.index(&FullRange), packed, t), dtor)
}
ty::ty_unboxed_closure(def_id, _, substs) => {
let typer = NormalizingUnboxedClosureTyper::new(cx.tcx());
let upvars = typer.unboxed_closure_upvars(def_id, substs).unwrap();
let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
- Univariant(mk_struct(cx, upvar_types[], false, t), false)
+ Univariant(mk_struct(cx, upvar_types.index(&FullRange), false, t), false)
}
ty::ty_enum(def_id, substs) => {
let cases = get_cases(cx.tcx(), def_id, substs);
- let hint = *ty::lookup_repr_hints(cx.tcx(), def_id)[].get(0)
+ let hint = *ty::lookup_repr_hints(cx.tcx(), def_id).index(&FullRange).get(0)
.unwrap_or(&attr::ReprAny);
let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag();
// (Typechecking will reject discriminant-sizing attrs.)
assert_eq!(hint, attr::ReprAny);
let ftys = if dtor { vec!(cx.tcx().types.bool) } else { vec!() };
- return Univariant(mk_struct(cx, ftys[], false, t),
+ return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t),
dtor);
}
cx.sess().bug(format!("non-C-like enum {} with specified \
discriminants",
ty::item_path_str(cx.tcx(),
- def_id))[]);
+ def_id)).index(&FullRange));
}
if cases.len() == 1 {
assert_eq!(hint, attr::ReprAny);
let mut ftys = cases[0].tys.clone();
if dtor { ftys.push(cx.tcx().types.bool); }
- return Univariant(mk_struct(cx, ftys[], false, t),
+ return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t),
dtor);
}
let mut discr = 0;
while discr < 2 {
if cases[1 - discr].is_zerolen(cx, t) {
- let st = mk_struct(cx, cases[discr].tys[],
+ let st = mk_struct(cx, cases[discr].tys.index(&FullRange),
false, t);
match cases[discr].find_ptr(cx) {
Some(ref df) if df.len() == 1 && st.fields.len() == 1 => {
let fields : Vec<_> = cases.iter().map(|c| {
let mut ftys = vec!(ty_of_inttype(cx.tcx(), ity));
- ftys.push_all(c.tys[]);
+ ftys.push_all(c.tys.index(&FullRange));
if dtor { ftys.push(cx.tcx().types.bool); }
- mk_struct(cx, ftys[], false, t)
+ mk_struct(cx, ftys.index(&FullRange), false, t)
}).collect();
- ensure_enum_fits_in_address_space(cx, ity, fields[], t);
+ ensure_enum_fits_in_address_space(cx, ity, fields.index(&FullRange), t);
General(ity, fields, dtor)
}
_ => cx.sess().bug(format!("adt::represent_type called on non-ADT type: {}",
- ty_to_string(cx.tcx(), t))[])
+ ty_to_string(cx.tcx(), t)).index(&FullRange))
}
}
impl<'tcx> Case<'tcx> {
fn is_zerolen<'a>(&self, cx: &CrateContext<'a, 'tcx>, scapegoat: Ty<'tcx>) -> bool {
- mk_struct(cx, self.tys[], false, scapegoat).size == 0
+ mk_struct(cx, self.tys.index(&FullRange), false, scapegoat).size == 0
}
fn find_ptr<'a>(&self, cx: &CrateContext<'a, 'tcx>) -> Option<DiscrField> {
.map(|&ty| type_of::sizing_type_of(cx, ty)).collect()
};
- ensure_struct_fits_in_address_space(cx, lltys[], packed, scapegoat);
+ ensure_struct_fits_in_address_space(cx, lltys.index(&FullRange), packed, scapegoat);
- let llty_rec = Type::struct_(cx, lltys[], packed);
+ let llty_rec = Type::struct_(cx, lltys.index(&FullRange), packed);
Struct {
size: machine::llsize_of_alloc(cx, llty_rec),
align: machine::llalign_of_min(cx, llty_rec),
}
fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntType {
- debug!("range_to_inttype: {} {}", hint, bounds);
+ debug!("range_to_inttype: {:?} {:?}", hint, bounds);
// Lists of sizes to try. u64 is always allowed as a fallback.
#[allow(non_upper_case_globals)]
static choose_shortest: &'static[IntType] = &[
return ity;
}
attr::ReprExtern => {
- attempts = match cx.sess().target.target.arch[] {
+ attempts = match cx.sess().target.target.arch.index(&FullRange) {
// WARNING: the ARM EABI has two variants; the one corresponding to `at_least_32`
// appears to be used on Linux and NetBSD, but some systems may use the variant
// corresponding to `choose_shortest`. However, we don't run on those yet...?
}
fn bounds_usable(cx: &CrateContext, ity: IntType, bounds: &IntBounds) -> bool {
- debug!("bounds_usable: {} {}", ity, bounds);
+ debug!("bounds_usable: {:?} {:?}", ity, bounds);
match ity {
attr::SignedInt(_) => {
let lllo = C_integral(ll_inttype(cx, ity), bounds.slo as u64, true);
match *r {
CEnum(..) | General(..) | RawNullablePointer { .. } => { }
Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } =>
- llty.set_struct_body(struct_llfields(cx, st, false, false)[],
+ llty.set_struct_body(struct_llfields(cx, st, false, false).index(&FullRange),
st.packed)
}
}
Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } => {
match name {
None => {
- Type::struct_(cx, struct_llfields(cx, st, sizing, dst)[],
+ Type::struct_(cx, struct_llfields(cx, st, sizing, dst).index(&FullRange),
st.packed)
}
Some(name) => { assert_eq!(sizing, false); Type::named_struct(cx, name) }
// of the size.
//
// FIXME #10604: this breaks when vector types are present.
- let (size, align) = union_size_and_align(sts[]);
+ let (size, align) = union_size_and_align(sts.index(&FullRange));
let align_s = align as u64;
let discr_ty = ll_inttype(cx, ity);
let discr_size = machine::llsize_of_alloc(cx, discr_ty);
Type::array(&discr_ty, align_s / discr_size - 1),
fill_ty];
match name {
- None => Type::struct_(cx, fields[], false),
+ None => Type::struct_(cx, fields.index(&FullRange), false),
Some(name) => {
let mut llty = Type::named_struct(cx, name);
- llty.set_struct_body(fields[], false);
+ llty.set_struct_body(fields.index(&FullRange), false);
llty
}
}
-> ValueRef {
let signed;
let val;
- debug!("trans_get_discr r: {}", r);
+ debug!("trans_get_discr r: {:?}", r);
match *r {
CEnum(ity, min, max) => {
val = load_discr(bcx, ity, scrutinee, min, max);
fn struct_wrapped_nullable_bitdiscr(bcx: Block, nndiscr: Disr, discrfield: &DiscrField,
scrutinee: ValueRef) -> ValueRef {
- let llptrptr = GEPi(bcx, scrutinee, discrfield[]);
+ let llptrptr = GEPi(bcx, scrutinee, discrfield.index(&FullRange));
let llptr = Load(bcx, llptrptr);
let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
ICmp(bcx, cmp, llptr, C_null(val_ty(llptr)))
}
StructWrappedNullablePointer { nndiscr, ref discrfield, .. } => {
if discr != nndiscr {
- let llptrptr = GEPi(bcx, val, discrfield[]);
+ let llptrptr = GEPi(bcx, val, discrfield.index(&FullRange));
let llptrty = val_ty(llptrptr).element_type();
Store(bcx, C_null(llptrty), llptrptr)
}
let val = if needs_cast {
let ccx = bcx.ccx();
let fields = st.fields.iter().map(|&ty| type_of::type_of(ccx, ty)).collect::<Vec<_>>();
- let real_ty = Type::struct_(ccx, fields[], st.packed);
+ let real_ty = Type::struct_(ccx, fields.index(&FullRange), st.packed);
PointerCast(bcx, val, real_ty.ptr_to())
} else {
val
for (discr, case) in cases.iter().enumerate() {
let mut variant_cx = fcx.new_temp_block(
- format!("enum-variant-iter-{}", discr.to_string())[]
+ format!("enum-variant-iter-{}", discr.to_string()).index(&FullRange)
);
let rhs_val = C_integral(ll_inttype(ccx, ity), discr as u64, true);
AddCase(llswitch, rhs_val, variant_cx.llbb);
let fields = case.fields.iter().map(|&ty|
type_of::type_of(bcx.ccx(), ty)).collect::<Vec<_>>();
- let real_ty = Type::struct_(ccx, fields[], case.packed);
+ let real_ty = Type::struct_(ccx, fields.index(&FullRange), case.packed);
let variant_value = PointerCast(variant_cx, value, real_ty.ptr_to());
variant_cx = f(variant_cx, case, variant_value);
let lldiscr = C_integral(ll_inttype(ccx, ity), discr as u64, true);
let mut f = vec![lldiscr];
f.push_all(vals);
- let mut contents = build_const_struct(ccx, case, f[]);
+ let mut contents = build_const_struct(ccx, case, f.index(&FullRange));
contents.push_all(&[padding(ccx, max_sz - case.size)]);
- C_struct(ccx, contents[], false)
+ C_struct(ccx, contents.index(&FullRange), false)
}
Univariant(ref st, _dro) => {
assert!(discr == 0);
let contents = build_const_struct(ccx, st, vals);
- C_struct(ccx, contents[], st.packed)
+ C_struct(ccx, contents.index(&FullRange), st.packed)
}
RawNullablePointer { nndiscr, nnty, .. } => {
if discr == nndiscr {
if discr == nndiscr {
C_struct(ccx, build_const_struct(ccx,
nonnull,
- vals)[],
+ vals).index(&FullRange),
false)
} else {
let vals = nonnull.fields.iter().map(|&ty| {
}).collect::<Vec<ValueRef>>();
C_struct(ccx, build_const_struct(ccx,
nonnull,
- vals[])[],
+ vals.index(&FullRange)).index(&FullRange),
false)
}
}
callee::DontAutorefArg)
})
}).collect::<Vec<_>>();
- inputs.push_all(ext_inputs[]);
+ inputs.push_all(ext_inputs.index(&FullRange));
// no failure occurred preparing operands, no need to cleanup
fcx.pop_custom_cleanup_scope(temp_scope);
if !clobbers.is_empty() {
clobbers.push(',');
}
- clobbers.push_str(more_clobbers[]);
+ clobbers.push_str(more_clobbers.index(&FullRange));
}
// Add the clobbers to our constraints list
if clobbers.len() != 0 && constraints.len() != 0 {
constraints.push(',');
- constraints.push_str(clobbers[]);
+ constraints.push_str(clobbers.index(&FullRange));
} else {
- constraints.push_str(clobbers[]);
+ constraints.push_str(clobbers.index(&FullRange));
}
- debug!("Asm Constraints: {}", constraints[]);
+ debug!("Asm Constraints: {}", constraints.index(&FullRange));
let num_outputs = outputs.len();
} else if num_outputs == 1 {
output_types[0]
} else {
- Type::struct_(bcx.ccx(), output_types[], false)
+ Type::struct_(bcx.ccx(), output_types.index(&FullRange), false)
};
let dialect = match ia.dialect {
let f = decl_rust_fn(ccx, fn_ty, name);
csearch::get_item_attrs(&ccx.sess().cstore, did, |attrs| {
- set_llvm_fn_attrs(ccx, attrs[], f)
+ set_llvm_fn_attrs(ccx, attrs.index(&FullRange), f)
});
ccx.externs().borrow_mut().insert(name.to_string(), f);
fn_ty: Ty<'tcx>, name: &str) -> ValueRef {
let fn_ty = monomorphize::normalize_associated_type(ccx.tcx(), &fn_ty);
- let (inputs, output, abi, env) = match fn_ty.sty {
+ let function_type; // placeholder so that the memory ownership works out ok
+
+ let (sig, abi, env) = match fn_ty.sty {
ty::ty_bare_fn(_, ref f) => {
- (f.sig.0.inputs.clone(), f.sig.0.output, f.abi, None)
+ (&f.sig, f.abi, None)
}
ty::ty_unboxed_closure(closure_did, _, substs) => {
let typer = common::NormalizingUnboxedClosureTyper::new(ccx.tcx());
- let function_type = typer.unboxed_closure_type(closure_did, substs);
+ function_type = typer.unboxed_closure_type(closure_did, substs);
let self_type = self_type_for_unboxed_closure(ccx, closure_did, fn_ty);
let llenvironment_type = type_of_explicit_arg(ccx, self_type);
debug!("decl_rust_fn: function_type={} self_type={}",
function_type.repr(ccx.tcx()),
self_type.repr(ccx.tcx()));
- (function_type.sig.0.inputs,
- function_type.sig.0.output,
- RustCall,
- Some(llenvironment_type))
+ (&function_type.sig, RustCall, Some(llenvironment_type))
}
_ => panic!("expected closure or fn")
};
- let llfty = type_of_rust_fn(ccx, env, inputs[], output, abi);
- debug!("decl_rust_fn(input count={},type={})",
- inputs.len(),
+ let sig = ty::erase_late_bound_regions(ccx.tcx(), sig);
+ let sig = ty::Binder(sig);
+
+ let llfty = type_of_rust_fn(ccx, env, &sig, abi);
+
+ debug!("decl_rust_fn(sig={}, type={})",
+ sig.repr(ccx.tcx()),
ccx.tn().type_to_string(llfty));
- let llfn = decl_fn(ccx, name, llvm::CCallConv, llfty, output);
+ let llfn = decl_fn(ccx, name, llvm::CCallConv, llfty, sig.0.output /* (1) */);
let attrs = get_fn_llvm_attributes(ccx, fn_ty);
attrs.apply_llfn(llfn);
+ // (1) it's ok to directly access sig.0.output because we erased all late-bound-regions above
+
llfn
}
Err(s) => {
bcx.sess().fatal(format!("allocation of `{}` {}",
bcx.ty_to_string(info_ty),
- s)[]);
+ s).index(&FullRange));
}
}
}
// silently mangles such symbols, breaking our linkage model.
pub fn note_unique_llvm_symbol(ccx: &CrateContext, sym: String) {
if ccx.all_llvm_symbols().borrow().contains(&sym) {
- ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym)[]);
+ ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym).index(&FullRange));
}
ccx.all_llvm_symbols().borrow_mut().insert(sym);
}
ty::mk_nil(ccx.tcx()));
get_extern_fn(ccx,
&mut *ccx.externs().borrow_mut(),
- name[],
+ name.index(&FullRange),
llvm::CCallConv,
llty,
dtor_ty)
let variant_cx =
fcx.new_temp_block(
format!("enum-iter-variant-{}",
- variant.disr_val.to_string()[])
- []);
+ variant.disr_val.to_string().index(&FullRange))
+ .index(&FullRange));
match adt::trans_case(cx, &*repr, variant.disr_val) {
_match::SingleResult(r) => {
AddCase(llswitch, r.val, variant_cx.llbb)
}
_ => {
cx.sess().unimpl(format!("type in iter_structural_ty: {}",
- ty_to_string(cx.tcx(), t))[])
+ ty_to_string(cx.tcx(), t)).index(&FullRange))
}
}
return cx;
}
_ => {
cx.sess().bug(format!("fail-if-zero on unexpected type: {}",
- ty_to_string(cx.tcx(), rhs_t))[]);
+ ty_to_string(cx.tcx(), rhs_t)).index(&FullRange));
}
};
let bcx = with_cond(cx, is_zero, |bcx| {
ty::ty_int(t) => {
let llty = Type::int_from_ty(cx.ccx(), t);
let min = match t {
- ast::TyI if llty == Type::i32(cx.ccx()) => i32::MIN as u64,
- ast::TyI => i64::MIN as u64,
+ ast::TyIs if llty == Type::i32(cx.ccx()) => i32::MIN as u64,
+ ast::TyIs => i64::MIN as u64,
ast::TyI8 => i8::MIN as u64,
ast::TyI16 => i16::MIN as u64,
ast::TyI32 => i32::MIN as u64,
ty::ty_bare_fn(_, ref fn_ty) => {
match ccx.sess().target.target.adjust_abi(fn_ty.abi) {
Rust | RustCall => {
- get_extern_rust_fn(ccx, t, name[], did)
+ get_extern_rust_fn(ccx, t, name.index(&FullRange), did)
}
RustIntrinsic => {
ccx.sess().bug("unexpected intrinsic in trans_external_path")
}
_ => {
foreign::register_foreign_item_fn(ccx, fn_ty.abi, t,
- name[])
+ name.index(&FullRange))
}
}
}
}
if need_invoke(bcx) {
- debug!("invoking {} at {}", bcx.val_to_string(llfn), bcx.llbb);
+ debug!("invoking {} at {:?}", bcx.val_to_string(llfn), bcx.llbb);
for &llarg in llargs.iter() {
debug!("arg: {}", bcx.val_to_string(llarg));
}
let llresult = Invoke(bcx,
llfn,
- llargs[],
+ llargs.index(&FullRange),
normal_bcx.llbb,
landing_pad,
Some(attributes));
return (llresult, normal_bcx);
} else {
- debug!("calling {} at {}", bcx.val_to_string(llfn), bcx.llbb);
+ debug!("calling {} at {:?}", bcx.val_to_string(llfn), bcx.llbb);
for &llarg in llargs.iter() {
debug!("arg: {}", bcx.val_to_string(llarg));
}
None => debuginfo::clear_source_location(bcx.fcx)
};
- let llresult = Call(bcx, llfn, llargs[], Some(attributes));
+ let llresult = Call(bcx, llfn, llargs.index(&FullRange), Some(attributes));
return (llresult, bcx);
}
}
pub fn call_memcpy(cx: Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef, align: u32) {
let _icx = push_ctxt("call_memcpy");
let ccx = cx.ccx();
- let key = match ccx.sess().target.target.target_word_size[] {
+ let key = match ccx.sess().target.target.target_word_size.index(&FullRange) {
"32" => "llvm.memcpy.p0i8.p0i8.i32",
"64" => "llvm.memcpy.p0i8.p0i8.i64",
tws => panic!("Unsupported target word size for memcpy: {}", tws),
let llty = type_of::type_of(ccx, ty);
- let intrinsic_key = match ccx.sess().target.target.target_word_size[] {
+ let intrinsic_key = match ccx.sess().target.target.target_word_size.index(&FullRange) {
"32" => "llvm.memset.p0i8.i32",
"64" => "llvm.memset.p0i8.i64",
tws => panic!("Unsupported target word size for memset: {}", tws),
"argtuple",
arg_scope_id));
let untupled_arg_types = match monomorphized_arg_types[0].sty {
- ty::ty_tup(ref types) => types[],
+ ty::ty_tup(ref types) => types.index(&FullRange),
_ => {
bcx.tcx().sess.span_bug(args[0].pat.span,
"first arg to `rust-call` ABI function \
let arg_datums = if abi != RustCall {
create_datums_for_fn_args(&fcx,
- monomorphized_arg_types[])
+ monomorphized_arg_types.index(&FullRange))
} else {
create_datums_for_fn_args_under_call_abi(
bcx,
arg_scope,
- monomorphized_arg_types[])
+ monomorphized_arg_types.index(&FullRange))
};
bcx = match closure_env.kind {
copy_args_to_allocas(&fcx,
arg_scope,
bcx,
- decl.inputs[],
+ decl.inputs.index(&FullRange),
arg_datums)
}
closure::UnboxedClosure(..) => {
copy_unboxed_closure_args_to_allocas(
bcx,
arg_scope,
- decl.inputs[],
+ decl.inputs.index(&FullRange),
arg_datums,
- monomorphized_arg_types[])
+ monomorphized_arg_types.index(&FullRange))
}
};
debug!("trans_fn(param_substs={})", param_substs.repr(ccx.tcx()));
let _icx = push_ctxt("trans_fn");
let fn_ty = ty::node_id_to_type(ccx.tcx(), id);
- let output_type = ty::ty_fn_ret(fn_ty);
+ let output_type = ty::erase_late_bound_regions(ccx.tcx(), &ty::ty_fn_ret(fn_ty));
let abi = ty::ty_fn_abi(fn_ty);
trans_closure(ccx,
decl,
let tcx = ccx.tcx();
let result_ty = match ctor_ty.sty {
- ty::ty_bare_fn(_, ref bft) => bft.sig.0.output.unwrap(),
+ ty::ty_bare_fn(_, ref bft) => {
+ ty::erase_late_bound_regions(bcx.tcx(), &bft.sig.output()).unwrap()
+ }
_ => ccx.sess().bug(
format!("trans_enum_variant_constructor: \
unexpected ctor return type {}",
- ctor_ty.repr(tcx))[])
+ ctor_ty.repr(tcx)).index(&FullRange))
};
// Get location to store the result. If the user does not care about
bcx = expr::trans_adt(bcx,
result_ty,
disr,
- fields[],
+ fields.index(&FullRange),
None,
expr::SaveIn(llresult),
call_info);
let ctor_ty = monomorphize::apply_param_substs(ccx.tcx(), param_substs, &ctor_ty);
let result_ty = match ctor_ty.sty {
- ty::ty_bare_fn(_, ref bft) => bft.sig.0.output,
+ ty::ty_bare_fn(_, ref bft) => {
+ ty::erase_late_bound_regions(ccx.tcx(), &bft.sig.output())
+ }
_ => ccx.sess().bug(
format!("trans_enum_variant_or_tuple_like_struct: \
unexpected ctor return type {}",
- ty_to_string(ccx.tcx(), ctor_ty))[])
+ ty_to_string(ccx.tcx(), ctor_ty)).index(&FullRange))
};
let arena = TypedArena::new();
assert!(!fcx.needs_ret_allocas);
- let arg_tys = ty::ty_fn_args(ctor_ty);
+ let arg_tys =
+ ty::erase_late_bound_regions(
+ ccx.tcx(), &ty::ty_fn_args(ctor_ty));
- let arg_datums = create_datums_for_fn_args(&fcx, arg_tys[]);
+ let arg_datums = create_datums_for_fn_args(&fcx, arg_tys.index(&FullRange));
if !type_is_zero_size(fcx.ccx, result_ty.unwrap()) {
let dest = fcx.get_ret_slot(bcx, result_ty, "eret_slot");
*lvlsrc.unwrap(), Some(sp),
format!("enum variant is more than three times larger \
({} bytes) than the next largest (ignoring padding)",
- largest)[]);
+ largest).index(&FullRange));
ccx.sess().span_note(enum_def.variants[largest_index].span,
"this variant is the largest");
if let Some(id) = id {
let item = ccx.tcx().map.get(id);
if let ast_map::NodeItem(i) = item {
- if let Some(name) = attr::first_attr_value_str_by_name(i.attrs[], "linkage") {
+ if let Some(name) = attr::first_attr_value_str_by_name(i.attrs.as_slice(), "linkage") {
if let Some(linkage) = llvm_linkage_by_name(name.get()) {
llvm::SetLinkage(llval, linkage);
} else {
match item.node {
ast::ItemFn(ref decl, _fn_style, abi, ref generics, ref body) => {
if !generics.is_type_parameterized() {
- let trans_everywhere = attr::requests_inline(item.attrs[]);
+ let trans_everywhere = attr::requests_inline(item.attrs.index(&FullRange));
// Ignore `trans_everywhere` for cross-crate inlined items
// (`from_external`). `trans_item` will be called once for each
// compilation unit that references the item, so it will still get
foreign::trans_rust_fn_with_foreign_abi(ccx,
&**decl,
&**body,
- item.attrs[],
+ item.attrs.index(&FullRange),
llfn,
&Substs::trans_empty(),
item.id,
llfn,
&Substs::trans_empty(),
item.id,
- item.attrs[]);
+ item.attrs.index(&FullRange));
}
update_linkage(ccx,
llfn,
ast::ItemImpl(_, _, ref generics, _, _, ref impl_items) => {
meth::trans_impl(ccx,
item.ident,
- impl_items[],
+ impl_items.index(&FullRange),
generics,
item.id);
}
// Do static_assert checking. It can't really be done much earlier
// because we need to get the value of the bool out of LLVM
- if attr::contains_name(item.attrs[], "static_assert") {
+ if attr::contains_name(item.attrs.index(&FullRange), "static_assert") {
if m == ast::MutMutable {
ccx.sess().span_fatal(expr.span,
"cannot have static_assert on a mutable \
_ => panic!("expected bare rust fn")
};
- let llfn = decl_rust_fn(ccx, node_type, sym[]);
+ let llfn = decl_rust_fn(ccx, node_type, sym.index(&FullRange));
finish_register_fn(ccx, sp, sym, node_id, llfn);
llfn
}
pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>)
- -> llvm::AttrBuilder {
+ -> llvm::AttrBuilder
+{
use middle::ty::{BrAnon, ReLateBound};
+ let function_type;
let (fn_sig, abi, has_env) = match fn_ty.sty {
- ty::ty_bare_fn(_, ref f) => (f.sig.clone(), f.abi, false),
+ ty::ty_bare_fn(_, ref f) => (&f.sig, f.abi, false),
ty::ty_unboxed_closure(closure_did, _, substs) => {
let typer = common::NormalizingUnboxedClosureTyper::new(ccx.tcx());
- let function_type = typer.unboxed_closure_type(closure_did, substs);
- (function_type.sig, RustCall, true)
+ function_type = typer.unboxed_closure_type(closure_did, substs);
+ (&function_type.sig, RustCall, true)
}
_ => ccx.sess().bug("expected closure or function.")
};
+ let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig);
// Since index 0 is the return value of the llvm func, we start
// at either 1 or 2 depending on whether there's an env slot or not
let mut first_arg_offset = if has_env { 2 } else { 1 };
let mut attrs = llvm::AttrBuilder::new();
- let ret_ty = fn_sig.0.output;
+ let ret_ty = fn_sig.output;
// These have an odd calling convention, so we need to manually
// unpack the input ty's
ty::ty_unboxed_closure(_, _, _) => {
assert!(abi == RustCall);
- match fn_sig.0.inputs[0].sty {
+ match fn_sig.inputs[0].sty {
ty::ty_tup(ref inputs) => inputs.clone(),
_ => ccx.sess().bug("expected tuple'd inputs")
}
},
ty::ty_bare_fn(..) if abi == RustCall => {
- let mut inputs = vec![fn_sig.0.inputs[0]];
+ let mut inputs = vec![fn_sig.inputs[0]];
- match fn_sig.0.inputs[1].sty {
+ match fn_sig.inputs[1].sty {
ty::ty_tup(ref t_in) => {
- inputs.push_all(t_in[]);
+ inputs.push_all(t_in.index(&FullRange));
inputs
}
_ => ccx.sess().bug("expected tuple'd inputs")
}
}
- _ => fn_sig.0.inputs.clone()
+ _ => fn_sig.inputs.clone()
};
if let ty::FnConverging(ret_ty) = ret_ty {
llfty: Type) -> ValueRef {
debug!("register_fn_llvmty id={} sym={}", node_id, sym);
- let llfn = decl_fn(ccx, sym[], cc, llfty, ty::FnConverging(ty::mk_nil(ccx.tcx())));
+ let llfn = decl_fn(ccx,
+ sym.index(&FullRange),
+ cc,
+ llfty,
+ ty::FnConverging(ty::mk_nil(ccx.tcx())));
finish_register_fn(ccx, sp, sym, node_id, llfn);
llfn
}
let (start_fn, args) = if use_start_lang_item {
let start_def_id = match ccx.tcx().lang_items.require(StartFnLangItem) {
Ok(id) => id,
- Err(s) => { ccx.sess().fatal(s[]); }
+ Err(s) => { ccx.sess().fatal(s.index(&FullRange)); }
};
let start_fn = if start_def_id.krate == ast::LOCAL_CRATE {
get_item_val(ccx, start_def_id.node)
}
let item = ccx.tcx().map.get(id);
- debug!("get_item_val: id={} item={}", id, item);
+ debug!("get_item_val: id={} item={:?}", id, item);
let val = match item {
ast_map::NodeItem(i) => {
let ty = ty::node_id_to_type(ccx.tcx(), i.id);
- let sym = |&:| exported_name(ccx, id, ty, i.attrs[]);
+ let sym = |&:| exported_name(ccx, id, ty, i.attrs.index(&FullRange));
let v = match i.node {
ast::ItemStatic(_, _, ref expr) => {
} else {
llvm::LLVMTypeOf(v)
};
- if contains_null(sym[]) {
+ if contains_null(sym.index(&FullRange)) {
ccx.sess().fatal(
format!("Illegal null byte in export_name \
- value: `{}`", sym)[]);
+ value: `{}`", sym).index(&FullRange));
}
let buf = CString::from_slice(sym.as_bytes());
let g = llvm::LLVMAddGlobal(ccx.llmod(), llty,
buf.as_ptr());
- if attr::contains_name(i.attrs[],
+ if attr::contains_name(i.attrs.index(&FullRange),
"thread_local") {
llvm::set_thread_local(g, true);
}
sym,
i.id)
};
- set_llvm_fn_attrs(ccx, i.attrs[], llfn);
+ set_llvm_fn_attrs(ccx, i.attrs.index(&FullRange), llfn);
llfn
}
_ => panic!("get_item_val: weird result in table")
};
- match attr::first_attr_value_str_by_name(i.attrs[],
+ match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange),
"link_section") {
Some(sect) => {
if contains_null(sect.get()) {
ccx.sess().fatal(format!("Illegal null byte in link_section value: `{}`",
- sect.get())[]);
+ sect.get()).index(&FullRange));
}
unsafe {
let buf = CString::from_slice(sect.get().as_bytes());
let abi = ccx.tcx().map.get_foreign_abi(id);
let ty = ty::node_id_to_type(ccx.tcx(), ni.id);
let name = foreign::link_name(&*ni);
- foreign::register_foreign_item_fn(ccx, abi, ty, name.get()[])
+ foreign::register_foreign_item_fn(ccx, abi, ty, name.get().index(&FullRange))
}
ast::ForeignItemStatic(..) => {
foreign::register_static(ccx, &*ni)
let sym = exported_name(ccx,
id,
ty,
- enm.attrs[]);
+ enm.attrs.index(&FullRange));
llfn = match enm.node {
ast::ItemEnum(_, _) => {
id,
ty,
struct_item.attrs
- []);
+ .index(&FullRange));
let llfn = register_fn(ccx, struct_item.span,
sym, ctor_id, ty);
set_inline_hint(llfn);
}
ref variant => {
- ccx.sess().bug(format!("get_item_val(): unexpected variant: {}",
- variant)[])
+ ccx.sess().bug(format!("get_item_val(): unexpected variant: {:?}",
+ variant).index(&FullRange))
}
};
m: &ast::Method) -> ValueRef {
let mty = ty::node_id_to_type(ccx.tcx(), id);
- let sym = exported_name(ccx, id, mty, m.attrs[]);
+ let sym = exported_name(ccx, id, mty, m.attrs.index(&FullRange));
let llfn = register_fn(ccx, m.span, sym, id, mty);
- set_llvm_fn_attrs(ccx, m.attrs[], llfn);
+ set_llvm_fn_attrs(ccx, m.attrs.index(&FullRange), llfn);
llfn
}
Some(compressed) => compressed,
None => cx.sess().fatal("failed to compress metadata"),
}.as_slice());
- let llmeta = C_bytes_in_context(cx.metadata_llcx(), compressed[]);
+ let llmeta = C_bytes_in_context(cx.metadata_llcx(), compressed.index(&FullRange));
let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false);
let name = format!("rust_metadata_{}_{}",
cx.link_meta().crate_name,
let link_meta = link::build_link_meta(&tcx.sess, krate, name);
let codegen_units = tcx.sess.opts.cg.codegen_units;
- let shared_ccx = SharedCrateContext::new(link_meta.crate_name[],
+ let shared_ccx = SharedCrateContext::new(link_meta.crate_name.index(&FullRange),
codegen_units,
tcx,
export_map,
llmod: shared_ccx.metadata_llmod(),
};
let formats = shared_ccx.tcx().dependency_formats.borrow().clone();
- let no_builtins = attr::contains_name(krate.attrs[], "no_builtins");
+ let no_builtins = attr::contains_name(krate.attrs.index(&FullRange), "no_builtins");
let translation = CrateTranslation {
modules: modules,
for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) {
*small_vec_e = C_i32(self.ccx, ix as i32);
}
- self.inbounds_gep(base, small_vec[..ixs.len()])
+ self.inbounds_gep(base, small_vec.index(&(0..ixs.len())))
} else {
let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::<Vec<ValueRef>>();
self.count_insn("gepi");
- self.inbounds_gep(base, v[])
+ self.inbounds_gep(base, v.index(&FullRange))
}
}
let s = format!("{} ({})",
text,
self.ccx.sess().codemap().span_to_string(sp));
- debug!("{}", s[]);
- self.add_comment(s[]);
+ debug!("{}", s.index(&FullRange));
+ self.add_comment(s.index(&FullRange));
}
}
}).collect::<Vec<_>>();
debug!("Asm Output Type: {}", self.ccx.tn().type_to_string(output));
- let fty = Type::func(argtys[], &output);
+ let fty = Type::func(argtys.index(&FullRange), &output);
unsafe {
let v = llvm::LLVMInlineAsm(
fty.to_ref(), asm, cons, volatile, alignstack, dia as c_uint);
atys: &[Type],
rty: Type,
ret_def: bool) -> FnType {
- match ccx.sess().target.target.arch[] {
+ match ccx.sess().target.target.arch.index(&FullRange) {
"x86" => cabi_x86::compute_abi_info(ccx, atys, rty, ret_def),
"x86_64" => if ccx.sess().target.target.options.is_like_windows {
cabi_x86_win64::compute_abi_info(ccx, atys, rty, ret_def)
"aarch64" => cabi_aarch64::compute_abi_info(ccx, atys, rty, ret_def),
"mips" => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def),
a => ccx.sess().fatal((format!("unrecognized arch \"{}\" in target specification", a))
- []),
+ .index(&FullRange)),
}
}
tys.push(Type::i64(ccx));
}
SSEFv => {
- let vec_len = llvec_len(cls[i + 1u..]);
+ let vec_len = llvec_len(cls.index(&((i + 1u)..)));
let vec_ty = Type::vector(&Type::f32(ccx), (vec_len * 2u) as u64);
tys.push(vec_ty);
i += vec_len;
expr.span,
format!("type of callee is neither bare-fn nor closure: \
{}",
- bcx.ty_to_string(datum.ty))[]);
+ bcx.ty_to_string(datum.ty)).index(&FullRange));
}
}
}
def::DefSelfTy(..) | def::DefAssociatedPath(..) => {
bcx.tcx().sess.span_bug(
ref_expr.span,
- format!("cannot translate def {} \
- to a callable thing!", def)[]);
+ format!("cannot translate def {:?} \
+ to a callable thing!", def).index(&FullRange));
}
}
}
let _icx = push_ctxt("trans_fn_ref");
let substs = node_id_substs(ccx, node, param_substs);
- debug!("trans_fn_ref(def_id={}, node={}, substs={})",
+ debug!("trans_fn_ref(def_id={}, node={:?}, substs={})",
def_id.repr(ccx.tcx()),
node,
substs.repr(ccx.tcx()));
let _icx = push_ctxt("trans_fn_pointer_shim");
let tcx = ccx.tcx();
- let bare_fn_ty = ty::normalize_ty(tcx, bare_fn_ty);
+ let bare_fn_ty = normalize_ty(tcx, bare_fn_ty);
match ccx.fn_pointer_shims().borrow().get(&bare_fn_ty) {
Some(&llval) => { return llval; }
None => { }
// Construct the "tuply" version of `bare_fn_ty`. It takes two arguments: `self`,
// which is the fn pointer, and `args`, which is the arguments tuple.
- let (opt_def_id, input_tys, output_ty) =
+ let (opt_def_id, sig) =
match bare_fn_ty.sty {
ty::ty_bare_fn(opt_def_id,
&ty::BareFnTy { unsafety: ast::Unsafety::Normal,
- abi: synabi::Rust,
- sig: ty::Binder(ty::FnSig { inputs: ref input_tys,
- output: output_ty,
- variadic: false })}) =>
- {
- (opt_def_id, input_tys, output_ty)
+ abi: synabi::Rust,
+ ref sig }) => {
+ (opt_def_id, sig)
}
_ => {
tcx.sess.bug(format!("trans_fn_pointer_shim invoked on invalid type: {}",
- bare_fn_ty.repr(tcx))[]);
+ bare_fn_ty.repr(tcx)).index(&FullRange));
}
};
- let tuple_input_ty = ty::mk_tup(tcx, input_tys.to_vec());
+ let sig = ty::erase_late_bound_regions(tcx, sig);
+ let tuple_input_ty = ty::mk_tup(tcx, sig.inputs.to_vec());
let tuple_fn_ty = ty::mk_bare_fn(tcx,
opt_def_id,
tcx.mk_bare_fn(ty::BareFnTy {
sig: ty::Binder(ty::FnSig {
inputs: vec![bare_fn_ty_ref,
tuple_input_ty],
- output: output_ty,
+ output: sig.output,
variadic: false
})}));
debug!("tuple_fn_ty: {}", tuple_fn_ty.repr(tcx));
let llfn =
decl_internal_rust_fn(ccx,
tuple_fn_ty,
- function_name[]);
+ function_name.index(&FullRange));
//
let block_arena = TypedArena::new();
llfn,
ast::DUMMY_NODE_ID,
false,
- output_ty,
+ sig.output,
&empty_substs,
None,
&block_arena);
- let mut bcx = init_function(&fcx, false, output_ty);
+ let mut bcx = init_function(&fcx, false, sig.output);
// the first argument (`self`) will be ptr to the the fn pointer
let llfnpointer =
// the remaining arguments will be the untupled values
let llargs: Vec<_> =
- input_tys.iter()
+ sig.inputs.iter()
.enumerate()
.map(|(i, _)| get_param(fcx.llfn, fcx.arg_pos(i+1) as u32))
.collect();
assert!(!fcx.needs_ret_allocas);
let dest = fcx.llretslotptr.get().map(|_|
- expr::SaveIn(fcx.get_ret_slot(bcx, output_ty, "ret_slot"))
+ expr::SaveIn(fcx.get_ret_slot(bcx, sig.output, "ret_slot"))
);
bcx = trans_call_inner(bcx,
None,
bare_fn_ty,
|bcx, _| Callee { bcx: bcx, data: Fn(llfnpointer) },
- ArgVals(llargs[]),
+ ArgVals(llargs.index(&FullRange)),
dest).bcx;
- finish_fn(&fcx, bcx, output_ty);
+ finish_fn(&fcx, bcx, sig.output);
ccx.fn_pointer_shims().borrow_mut().insert(bare_fn_ty, llfn);
let _icx = push_ctxt("trans_fn_ref_with_substs");
let tcx = ccx.tcx();
- debug!("trans_fn_ref_with_substs(def_id={}, node={}, \
+ debug!("trans_fn_ref_with_substs(def_id={}, node={:?}, \
param_substs={}, substs={})",
def_id.repr(tcx),
node,
let mut bcx = callee.bcx;
let (abi, ret_ty) = match callee_ty.sty {
- ty::ty_bare_fn(_, ref f) => (f.abi, f.sig.0.output),
+ ty::ty_bare_fn(_, ref f) => {
+ let output = ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output());
+ (f.abi, output)
+ }
_ => panic!("expected bare rust fn or closure in trans_call_inner")
};
// Invoke the actual rust fn and update bcx/llresult.
let (llret, b) = base::invoke(bcx,
llfn,
- llargs[],
+ llargs.index(&FullRange),
callee_ty,
call_info);
bcx = b;
bcx = foreign::trans_native_call(bcx, callee_ty,
llfn, opt_llretslot.unwrap(),
- llargs[], arg_tys);
+ llargs.index(&FullRange), arg_tys);
}
fcx.pop_and_trans_custom_cleanup_scope(bcx, arg_cleanup_scope);
llargs: &mut Vec<ValueRef>,
arg_cleanup_scope: cleanup::ScopeId,
ignore_self: bool)
- -> Block<'blk, 'tcx> {
+ -> Block<'blk, 'tcx>
+{
+ let args =
+ ty::erase_late_bound_regions(
+ bcx.tcx(), &ty::ty_fn_args(fn_ty));
+
// Translate the `self` argument first.
if !ignore_self {
let arg_datum = unpack_datum!(bcx, expr::trans(bcx, &*arg_exprs[0]));
llargs.push(unpack_result!(bcx, {
trans_arg_datum(bcx,
- ty::ty_fn_args(fn_ty)[0],
+ args[0],
arg_datum,
arg_cleanup_scope,
DontAutorefArg)
ignore_self: bool)
-> Block<'blk, 'tcx> {
// Translate the `self` argument first.
- let arg_tys = ty::ty_fn_args(fn_ty);
+ let arg_tys = ty::erase_late_bound_regions(bcx.tcx(), &ty::ty_fn_args(fn_ty));
if !ignore_self {
let arg_datum = unpack_datum!(bcx, expr::trans(bcx, arg_exprs[0]));
llargs.push(unpack_result!(bcx, {
debug!("trans_args(abi={})", abi);
let _icx = push_ctxt("trans_args");
- let arg_tys = ty::ty_fn_args(fn_ty);
+ let arg_tys = ty::erase_late_bound_regions(cx.tcx(), &ty::ty_fn_args(fn_ty));
let variadic = ty::fn_is_variadic(fn_ty);
let mut bcx = cx;
use trans::common::{Block, FunctionContext, ExprId, NodeInfo};
use trans::debuginfo;
use trans::glue;
-// Temporary due to slicing syntax hacks (KILLME)
-//use middle::region;
+use middle::region;
use trans::type_::Type;
use middle::ty::{self, Ty};
use std::fmt;
// excluding id's that correspond to closure bodies only). For
// now we just say that if there is already an AST scope on the stack,
// this new AST scope had better be its immediate child.
- // Temporarily removed due to slicing syntax hacks (KILLME).
- /*let top_scope = self.top_ast_scope();
+ let top_scope = self.top_ast_scope();
if top_scope.is_some() {
assert_eq!(self.ccx
.tcx()
.opt_encl_scope(region::CodeExtent::from_node_id(debug_loc.id))
.map(|s|s.node_id()),
top_scope);
- }*/
+ }
self.push_scope(CleanupScope::new(AstScopeKind(debug_loc.id),
Some(debug_loc)));
bcx: Block<'blk, 'tcx>,
custom_scope: CustomScopeIndex)
-> Block<'blk, 'tcx> {
- debug!("pop_and_trans_custom_cleanup_scope({})", custom_scope);
+ debug!("pop_and_trans_custom_cleanup_scope({:?})", custom_scope);
assert!(self.is_valid_to_pop_custom_scope(custom_scope));
let scope = self.pop_scope();
ptr: val,
};
- debug!("schedule_lifetime_end({}, val={})",
+ debug!("schedule_lifetime_end({:?}, val={})",
cleanup_scope,
self.ccx.tn().val_to_string(val));
zero: false
};
- debug!("schedule_drop_mem({}, val={}, ty={})",
+ debug!("schedule_drop_mem({:?}, val={}, ty={})",
cleanup_scope,
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()));
zero: true
};
- debug!("schedule_drop_and_zero_mem({}, val={}, ty={}, zero={})",
+ debug!("schedule_drop_and_zero_mem({:?}, val={}, ty={}, zero={})",
cleanup_scope,
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()),
zero: false
};
- debug!("schedule_drop_immediate({}, val={}, ty={})",
+ debug!("schedule_drop_immediate({:?}, val={}, ty={:?})",
cleanup_scope,
self.ccx.tn().val_to_string(val),
ty.repr(self.ccx.tcx()));
content_ty: Ty<'tcx>) {
let drop = box FreeValue { ptr: val, heap: heap, content_ty: content_ty };
- debug!("schedule_free_value({}, val={}, heap={})",
+ debug!("schedule_free_value({:?}, val={}, heap={:?})",
cleanup_scope,
self.ccx.tn().val_to_string(val),
heap);
heap: Heap) {
let drop = box FreeSlice { ptr: val, size: size, align: align, heap: heap };
- debug!("schedule_free_slice({}, val={}, heap={})",
+ debug!("schedule_free_slice({:?}, val={}, heap={:?})",
cleanup_scope,
self.ccx.tn().val_to_string(val),
heap);
self.ccx.sess().bug(
format!("no cleanup scope {} found",
- self.ccx.tcx().map.node_to_string(cleanup_scope))[]);
+ self.ccx.tcx().map.node_to_string(cleanup_scope)).index(&FullRange));
}
/// Schedules a cleanup to occur in the top-most scope, which must be a temporary scope.
fn trans_cleanups_to_exit_scope(&'blk self,
label: EarlyExitLabel)
-> BasicBlockRef {
- debug!("trans_cleanups_to_exit_scope label={} scopes={}",
+ debug!("trans_cleanups_to_exit_scope label={:?} scopes={}",
label, self.scopes_len());
let orig_scopes_len = self.scopes_len();
LoopExit(id, _) => {
self.ccx.sess().bug(format!(
"cannot exit from scope {}, \
- not in scope", id)[]);
+ not in scope", id).index(&FullRange));
}
}
}
let name = scope.block_name("clean");
debug!("generating cleanups for {}", name);
let bcx_in = self.new_block(label.is_unwind(),
- name[],
+ name.index(&FullRange),
None);
let mut bcx_out = bcx_in;
for cleanup in scope.cleanups.iter().rev() {
self.push_scope(scope);
}
- debug!("trans_cleanups_to_exit_scope: prev_llbb={}", prev_llbb);
+ debug!("trans_cleanups_to_exit_scope: prev_llbb={:?}", prev_llbb);
assert_eq!(self.scopes_len(), orig_scopes_len);
prev_llbb
Some(llbb) => { return llbb; }
None => {
let name = last_scope.block_name("unwind");
- pad_bcx = self.new_block(true, name[], None);
+ pad_bcx = self.new_block(true, name.index(&FullRange), None);
last_scope.cached_landing_pad = Some(pad_bcx.llbb);
}
}
match tcx.region_maps.temporary_scope(id) {
Some(scope) => {
let r = AstScope(scope.node_id());
- debug!("temporary_scope({}) = {}", id, r);
+ debug!("temporary_scope({}) = {:?}", id, r);
r
}
None => {
tcx.sess.bug(format!("no temporary scope available for expr {}",
- id)[])
+ id).index(&FullRange))
}
}
}
id: ast::NodeId)
-> ScopeId {
let r = AstScope(tcx.region_maps.var_scope(id).node_id());
- debug!("var_scope({}) = {}", id, r);
+ debug!("var_scope({}) = {:?}", id, r);
r
}
impl<'tcx> EnvValue<'tcx> {
pub fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String {
- format!("{}({})", self.action, self.datum.to_string(ccx))
+ format!("{:?}({})", self.action, self.datum.to_string(ccx))
}
}
let tcx = ccx.tcx();
// compute the type of the closure
- let cdata_ty = mk_closure_tys(tcx, bound_values[]);
+ let cdata_ty = mk_closure_tys(tcx, bound_values.index(&FullRange));
// cbox_ty has the form of a tuple: (a, b, c) we want a ptr to a
// tuple. This could be a ptr in uniq or a box or on stack,
if ccx.sess().asm_comments() {
add_comment(bcx, format!("Copy {} into closure",
- bv.to_string(ccx))[]);
+ bv.to_string(ccx)).index(&FullRange));
}
let bound_data = GEPi(bcx, llbox, &[0u, abi::BOX_FIELD_BODY, i]);
let s = tcx.map.with_path(id, |path| {
mangle_internal_name_by_path_and_seq(path, "closure")
});
- let llfn = decl_internal_rust_fn(ccx, fty, s[]);
+ let llfn = decl_internal_rust_fn(ccx, fty, s.index(&FullRange));
// set an inline hint for all closures
set_inline_hint(llfn);
bcx.fcx.param_substs,
id,
&[],
- ty::ty_fn_ret(fty),
+ ty::erase_late_bound_regions(ccx.tcx(), &ty::ty_fn_ret(fty)),
ty::ty_fn_abi(fty),
- ClosureEnv::new(freevars[],
+ ClosureEnv::new(freevars.index(&FullRange),
BoxedClosure(cdata_ty, store)));
fill_fn_pair(bcx, dest_addr, llfn, llbox);
bcx
// Normalize type so differences in regions and typedefs don't cause
// duplicate declarations
- let function_type = ty::normalize_ty(ccx.tcx(), function_type);
+ let function_type = normalize_ty(ccx.tcx(), function_type);
let params = match function_type.sty {
ty::ty_unboxed_closure(_, _, ref substs) => substs.types.clone(),
_ => unreachable!()
mangle_internal_name_by_path_and_seq(path, "unboxed_closure")
});
- let llfn = decl_internal_rust_fn(ccx, function_type, symbol[]);
+ let llfn = decl_internal_rust_fn(ccx, function_type, symbol.index(&FullRange));
// set an inline hint for all closures
set_inline_hint(llfn);
debug!("get_or_create_declaration_if_unboxed_closure(): inserting new \
- closure {} (type {})",
+ closure {:?} (type {})",
mono_id,
ccx.tn().type_to_string(val_ty(llfn)));
ccx.unboxed_closure_vals().borrow_mut().insert(mono_id, llfn);
ty::with_freevars(bcx.tcx(), id, |fv| fv.iter().map(|&fv| fv).collect());
let freevar_mode = bcx.tcx().capture_mode(id);
+ let sig = ty::erase_late_bound_regions(bcx.tcx(), &function_type.sig);
+
trans_closure(bcx.ccx(),
decl,
body,
bcx.fcx.param_substs,
id,
&[],
- function_type.sig.0.output,
+ sig.output,
function_type.abi,
- ClosureEnv::new(freevars[],
+ ClosureEnv::new(freevars.index(&FullRange),
UnboxedClosure(freevar_mode)));
// Don't hoist this to the top of the function. It's perfectly legitimate
bcx
}
+
pub use trans::context::CrateContext;
+/// Returns an equivalent type with all the typedefs and self regions removed.
+pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
+ let u = TypeNormalizer(cx).fold_ty(ty);
+ debug!("normalize_ty({}) = {}",
+ ty.repr(cx), u.repr(cx));
+ return u;
+
+ struct TypeNormalizer<'a, 'tcx: 'a>(&'a ty::ctxt<'tcx>);
+
+ impl<'a, 'tcx> TypeFolder<'tcx> for TypeNormalizer<'a, 'tcx> {
+ fn tcx(&self) -> &ty::ctxt<'tcx> { self.0 }
+
+ fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
+ match self.tcx().normalized_cache.borrow().get(&ty).cloned() {
+ None => {}
+ Some(u) => return u
+ }
+
+ let t_norm = ty_fold::super_fold_ty(self, ty);
+ self.tcx().normalized_cache.borrow_mut().insert(ty, t_norm);
+ return t_norm;
+ }
+
+ fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T>
+ where T : TypeFoldable<'tcx> + Repr<'tcx>
+ {
+ // FIXME(#20526) this should replace `enter_region_binder`/`exit_region_binder`.
+ let u = ty::anonymize_late_bound_regions(self.tcx(), t);
+ ty_fold::super_fold_binder(self, &u)
+ }
+
+ fn fold_region(&mut self, r: ty::Region) -> ty::Region {
+ // because late-bound regions affect subtyping, we can't
+ // erase the bound/free distinction, but we can replace
+ // all free regions with 'static.
+ //
+ // Note that we *CAN* replace early-bound regions -- the
+ // type system never "sees" those, they get substituted
+ // away. In trans, they will always be erased to 'static
+ // whenever a substitution occurs.
+ match r {
+ ty::ReLateBound(..) => r,
+ _ => ty::ReStatic
+ }
+ }
+
+ fn fold_substs(&mut self,
+ substs: &subst::Substs<'tcx>)
+ -> subst::Substs<'tcx> {
+ subst::Substs { regions: subst::ErasedRegions,
+ types: substs.types.fold_with(self) }
+ }
+ }
+}
+
// Is the type's representation size known at compile time?
pub fn type_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
- ty::type_contents(cx, ty).is_sized(cx)
+ty::type_contents(cx, ty).is_sized(cx)
}
pub fn lltype_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
- match ty.sty {
- ty::ty_open(_) => true,
- _ => type_is_sized(cx, ty),
- }
+match ty.sty {
+ ty::ty_open(_) => true,
+ _ => type_is_sized(cx, ty),
+}
}
pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
- match ty.sty {
- ty::ty_ptr(ty::mt{ty, ..}) |
- ty::ty_rptr(_, ty::mt{ty, ..}) |
- ty::ty_uniq(ty) => {
- !type_is_sized(cx, ty)
- }
- _ => {
- false
- }
+match ty.sty {
+ ty::ty_ptr(ty::mt{ty, ..}) |
+ ty::ty_rptr(_, ty::mt{ty, ..}) |
+ ty::ty_uniq(ty) => {
+ !type_is_sized(cx, ty)
}
+ _ => {
+ false
+ }
+}
}
// Return the smallest part of `ty` which is unsized. Fails if `ty` is sized.
// 'Smallest' here means component of the static representation of the type; not
// the size of an object at runtime.
pub fn unsized_part_of_type<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
- match ty.sty {
- ty::ty_str | ty::ty_trait(..) | ty::ty_vec(..) => ty,
- ty::ty_struct(def_id, substs) => {
- let unsized_fields: Vec<_> =
- ty::struct_fields(cx, def_id, substs)
- .iter()
- .map(|f| f.mt.ty)
- .filter(|ty| !type_is_sized(cx, *ty))
- .collect();
-
- // Exactly one of the fields must be unsized.
- assert!(unsized_fields.len() == 1);
-
- unsized_part_of_type(cx, unsized_fields[0])
- }
- _ => {
- assert!(type_is_sized(cx, ty),
- "unsized_part_of_type failed even though ty is unsized");
- panic!("called unsized_part_of_type with sized ty");
- }
+match ty.sty {
+ ty::ty_str | ty::ty_trait(..) | ty::ty_vec(..) => ty,
+ ty::ty_struct(def_id, substs) => {
+ let unsized_fields: Vec<_> =
+ ty::struct_fields(cx, def_id, substs)
+ .iter()
+ .map(|f| f.mt.ty)
+ .filter(|ty| !type_is_sized(cx, *ty))
+ .collect();
+
+ // Exactly one of the fields must be unsized.
+ assert!(unsized_fields.len() == 1);
+
+ unsized_part_of_type(cx, unsized_fields[0])
}
+ _ => {
+ assert!(type_is_sized(cx, ty),
+ "unsized_part_of_type failed even though ty is unsized");
+ panic!("called unsized_part_of_type with sized ty");
+ }
+}
}
// Some things don't need cleanups during unwinding because the
// that only contain scalars and shared boxes can avoid unwind
// cleanups.
pub fn type_needs_unwind_cleanup<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
- return memoized(ccx.needs_unwind_cleanup_cache(), ty, |ty| {
- type_needs_unwind_cleanup_(ccx.tcx(), ty, &mut FnvHashSet::new())
- });
+return memoized(ccx.needs_unwind_cleanup_cache(), ty, |ty| {
+ type_needs_unwind_cleanup_(ccx.tcx(), ty, &mut FnvHashSet::new())
+});
+
+fn type_needs_unwind_cleanup_<'tcx>(tcx: &ty::ctxt<'tcx>,
+ ty: Ty<'tcx>,
+ tycache: &mut FnvHashSet<Ty<'tcx>>)
+ -> bool
+{
+ // Prevent infinite recursion
+ if !tycache.insert(ty) {
+ return false;
+ }
- fn type_needs_unwind_cleanup_<'tcx>(tcx: &ty::ctxt<'tcx>,
- ty: Ty<'tcx>,
- tycache: &mut FnvHashSet<Ty<'tcx>>)
- -> bool
- {
- // Prevent infinite recursion
- if !tycache.insert(ty) {
- return false;
- }
+ let mut needs_unwind_cleanup = false;
+ ty::maybe_walk_ty(ty, |ty| {
+ needs_unwind_cleanup |= match ty.sty {
+ ty::ty_bool | ty::ty_int(_) | ty::ty_uint(_) |
+ ty::ty_float(_) | ty::ty_tup(_) | ty::ty_ptr(_) => false,
- let mut needs_unwind_cleanup = false;
- ty::maybe_walk_ty(ty, |ty| {
- needs_unwind_cleanup |= match ty.sty {
- ty::ty_bool | ty::ty_int(_) | ty::ty_uint(_) |
- ty::ty_float(_) | ty::ty_tup(_) | ty::ty_ptr(_) => false,
-
- ty::ty_enum(did, substs) =>
- ty::enum_variants(tcx, did).iter().any(|v|
- v.args.iter().any(|&aty| {
- let t = aty.subst(tcx, substs);
- type_needs_unwind_cleanup_(tcx, t, tycache)
- })
- ),
-
- _ => true
- };
- !needs_unwind_cleanup
- });
- needs_unwind_cleanup
- }
+ ty::ty_enum(did, substs) =>
+ ty::enum_variants(tcx, did).iter().any(|v|
+ v.args.iter().any(|&aty| {
+ let t = aty.subst(tcx, substs);
+ type_needs_unwind_cleanup_(tcx, t, tycache)
+ })
+ ),
+
+ _ => true
+ };
+ !needs_unwind_cleanup
+ });
+ needs_unwind_cleanup
+}
}
pub fn type_needs_drop<'tcx>(cx: &ty::ctxt<'tcx>,
- ty: Ty<'tcx>)
- -> bool {
- ty::type_contents(cx, ty).needs_drop(cx)
+ ty: Ty<'tcx>)
+ -> bool {
+ty::type_contents(cx, ty).needs_drop(cx)
}
fn type_is_newtype_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- ty: Ty<'tcx>) -> bool {
- match ty.sty {
- ty::ty_struct(def_id, substs) => {
- let fields = ty::struct_fields(ccx.tcx(), def_id, substs);
- fields.len() == 1 &&
- fields[0].name ==
- token::special_idents::unnamed_field.name &&
- type_is_immediate(ccx, fields[0].mt.ty)
- }
- _ => false
+ ty: Ty<'tcx>) -> bool {
+match ty.sty {
+ ty::ty_struct(def_id, substs) => {
+ let fields = ty::struct_fields(ccx.tcx(), def_id, substs);
+ fields.len() == 1 &&
+ fields[0].name ==
+ token::special_idents::unnamed_field.name &&
+ type_is_immediate(ccx, fields[0].mt.ty)
}
+ _ => false
+}
}
pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
- use trans::machine::llsize_of_alloc;
- use trans::type_of::sizing_type_of;
-
- let tcx = ccx.tcx();
- let simple = ty::type_is_scalar(ty) ||
- ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) ||
- type_is_newtype_immediate(ccx, ty) ||
- ty::type_is_simd(tcx, ty);
- if simple && !type_is_fat_ptr(tcx, ty) {
- return true;
- }
- if !type_is_sized(tcx, ty) {
- return false;
- }
- match ty.sty {
- ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) |
- ty::ty_unboxed_closure(..) => {
- let llty = sizing_type_of(ccx, ty);
- llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type())
- }
- _ => type_is_zero_size(ccx, ty)
+use trans::machine::llsize_of_alloc;
+use trans::type_of::sizing_type_of;
+
+let tcx = ccx.tcx();
+let simple = ty::type_is_scalar(ty) ||
+ ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) ||
+ type_is_newtype_immediate(ccx, ty) ||
+ ty::type_is_simd(tcx, ty);
+if simple && !type_is_fat_ptr(tcx, ty) {
+ return true;
+}
+if !type_is_sized(tcx, ty) {
+ return false;
+}
+match ty.sty {
+ ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) |
+ ty::ty_unboxed_closure(..) => {
+ let llty = sizing_type_of(ccx, ty);
+ llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type())
}
+ _ => type_is_zero_size(ccx, ty)
+}
}
/// Identify types which have size zero at runtime.
pub fn type_is_zero_size<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
- use trans::machine::llsize_of_alloc;
- use trans::type_of::sizing_type_of;
- let llty = sizing_type_of(ccx, ty);
- llsize_of_alloc(ccx, llty) == 0
+use trans::machine::llsize_of_alloc;
+use trans::type_of::sizing_type_of;
+let llty = sizing_type_of(ccx, ty);
+llsize_of_alloc(ccx, llty) == 0
}
/// Identifies types which we declare to be equivalent to `void` in C for the purpose of function
/// zero-size, but not all zero-size types use a `void` return type (in order to aid with C ABI
/// compatibility).
pub fn return_type_is_void(ccx: &CrateContext, ty: Ty) -> bool {
- ty::type_is_nil(ty) || ty::type_is_empty(ccx.tcx(), ty)
+ty::type_is_nil(ty) || ty::type_is_empty(ccx.tcx(), ty)
}
/// Generates a unique symbol based off the name given. This is used to create
/// unique symbols for things like closures.
pub fn gensym_name(name: &str) -> PathElem {
- let num = token::gensym(name).uint();
- // use one colon which will get translated to a period by the mangler, and
- // we're guaranteed that `num` is globally unique for this crate.
- PathName(token::gensym(format!("{}:{}", name, num)[]))
+let num = token::gensym(name).uint();
+// use one colon which will get translated to a period by the mangler, and
+// we're guaranteed that `num` is globally unique for this crate.
+PathName(token::gensym(format!("{}:{}", name, num).index(&FullRange)))
}
#[derive(Copy)]
pub struct tydesc_info<'tcx> {
- pub ty: Ty<'tcx>,
- pub tydesc: ValueRef,
- pub size: ValueRef,
- pub align: ValueRef,
- pub name: ValueRef,
+pub ty: Ty<'tcx>,
+pub tydesc: ValueRef,
+pub size: ValueRef,
+pub align: ValueRef,
+pub name: ValueRef,
}
/*
- * A note on nomenclature of linking: "extern", "foreign", and "upcall".
- *
- * An "extern" is an LLVM symbol we wind up emitting an undefined external
- * reference to. This means "we don't have the thing in this compilation unit,
- * please make sure you link it in at runtime". This could be a reference to
- * C code found in a C library, or rust code found in a rust crate.
- *
- * Most "externs" are implicitly declared (automatically) as a result of a
- * user declaring an extern _module_ dependency; this causes the rust driver
- * to locate an extern crate, scan its compilation metadata, and emit extern
- * declarations for any symbols used by the declaring crate.
- *
- * A "foreign" is an extern that references C (or other non-rust ABI) code.
- * There is no metadata to scan for extern references so in these cases either
- * a header-digester like bindgen, or manual function prototypes, have to
- * serve as declarators. So these are usually given explicitly as prototype
- * declarations, in rust code, with ABI attributes on them noting which ABI to
- * link via.
- *
- * An "upcall" is a foreign call generated by the compiler (not corresponding
- * to any user-written call in the code) into the runtime library, to perform
- * some helper task such as bringing a task to life, allocating memory, etc.
- *
- */
+* A note on nomenclature of linking: "extern", "foreign", and "upcall".
+*
+* An "extern" is an LLVM symbol we wind up emitting an undefined external
+* reference to. This means "we don't have the thing in this compilation unit,
+* please make sure you link it in at runtime". This could be a reference to
+* C code found in a C library, or rust code found in a rust crate.
+*
+* Most "externs" are implicitly declared (automatically) as a result of a
+* user declaring an extern _module_ dependency; this causes the rust driver
+* to locate an extern crate, scan its compilation metadata, and emit extern
+* declarations for any symbols used by the declaring crate.
+*
+* A "foreign" is an extern that references C (or other non-rust ABI) code.
+* There is no metadata to scan for extern references so in these cases either
+* a header-digester like bindgen, or manual function prototypes, have to
+* serve as declarators. So these are usually given explicitly as prototype
+* declarations, in rust code, with ABI attributes on them noting which ABI to
+* link via.
+*
+* An "upcall" is a foreign call generated by the compiler (not corresponding
+* to any user-written call in the code) into the runtime library, to perform
+* some helper task such as bringing a task to life, allocating memory, etc.
+*
+*/
#[derive(Copy)]
pub struct NodeInfo {
- pub id: ast::NodeId,
- pub span: Span,
+pub id: ast::NodeId,
+pub span: Span,
}
pub fn expr_info(expr: &ast::Expr) -> NodeInfo {
- NodeInfo { id: expr.id, span: expr.span }
+NodeInfo { id: expr.id, span: expr.span }
}
pub struct BuilderRef_res {
- pub b: BuilderRef,
+pub b: BuilderRef,
}
impl Drop for BuilderRef_res {
- fn drop(&mut self) {
- unsafe {
- llvm::LLVMDisposeBuilder(self.b);
- }
+fn drop(&mut self) {
+ unsafe {
+ llvm::LLVMDisposeBuilder(self.b);
}
}
+}
pub fn BuilderRef_res(b: BuilderRef) -> BuilderRef_res {
- BuilderRef_res {
- b: b
- }
+BuilderRef_res {
+ b: b
+}
}
pub type ExternMap = FnvHashMap<String, ValueRef>;
pub fn validate_substs(substs: &Substs) {
- assert!(substs.types.all(|t| !ty::type_needs_infer(*t)));
+assert!(substs.types.all(|t| !ty::type_needs_infer(*t)));
}
// work around bizarre resolve errors
// Function context. Every LLVM function we create will have one of
// these.
pub struct FunctionContext<'a, 'tcx: 'a> {
- // The ValueRef returned from a call to llvm::LLVMAddFunction; the
- // address of the first instruction in the sequence of
- // instructions for this function that will go in the .text
- // section of the executable we're generating.
- pub llfn: ValueRef,
+// The ValueRef returned from a call to llvm::LLVMAddFunction; the
+// address of the first instruction in the sequence of
+// instructions for this function that will go in the .text
+// section of the executable we're generating.
+pub llfn: ValueRef,
- // always an empty parameter-environment
- pub param_env: ty::ParameterEnvironment<'a, 'tcx>,
+// always an empty parameter-environment
+pub param_env: ty::ParameterEnvironment<'a, 'tcx>,
- // The environment argument in a closure.
- pub llenv: Option<ValueRef>,
+// The environment argument in a closure.
+pub llenv: Option<ValueRef>,
- // A pointer to where to store the return value. If the return type is
- // immediate, this points to an alloca in the function. Otherwise, it's a
- // pointer to the hidden first parameter of the function. After function
- // construction, this should always be Some.
- pub llretslotptr: Cell<Option<ValueRef>>,
+// A pointer to where to store the return value. If the return type is
+// immediate, this points to an alloca in the function. Otherwise, it's a
+// pointer to the hidden first parameter of the function. After function
+// construction, this should always be Some.
+pub llretslotptr: Cell<Option<ValueRef>>,
- // These pub elements: "hoisted basic blocks" containing
- // administrative activities that have to happen in only one place in
- // the function, due to LLVM's quirks.
- // A marker for the place where we want to insert the function's static
- // allocas, so that LLVM will coalesce them into a single alloca call.
- pub alloca_insert_pt: Cell<Option<ValueRef>>,
- pub llreturn: Cell<Option<BasicBlockRef>>,
+// These pub elements: "hoisted basic blocks" containing
+// administrative activities that have to happen in only one place in
+// the function, due to LLVM's quirks.
+// A marker for the place where we want to insert the function's static
+// allocas, so that LLVM will coalesce them into a single alloca call.
+pub alloca_insert_pt: Cell<Option<ValueRef>>,
+pub llreturn: Cell<Option<BasicBlockRef>>,
- // If the function has any nested return's, including something like:
- // fn foo() -> Option<Foo> { Some(Foo { x: return None }) }, then
- // we use a separate alloca for each return
- pub needs_ret_allocas: bool,
+// If the function has any nested return's, including something like:
+// fn foo() -> Option<Foo> { Some(Foo { x: return None }) }, then
+// we use a separate alloca for each return
+pub needs_ret_allocas: bool,
- // The a value alloca'd for calls to upcalls.rust_personality. Used when
- // outputting the resume instruction.
- pub personality: Cell<Option<ValueRef>>,
+// The a value alloca'd for calls to upcalls.rust_personality. Used when
+// outputting the resume instruction.
+pub personality: Cell<Option<ValueRef>>,
- // True if the caller expects this fn to use the out pointer to
- // return. Either way, your code should write into the slot llretslotptr
- // points to, but if this value is false, that slot will be a local alloca.
- pub caller_expects_out_pointer: bool,
+// True if the caller expects this fn to use the out pointer to
+// return. Either way, your code should write into the slot llretslotptr
+// points to, but if this value is false, that slot will be a local alloca.
+pub caller_expects_out_pointer: bool,
- // Maps the DefId's for local variables to the allocas created for
- // them in llallocas.
- pub lllocals: RefCell<NodeMap<LvalueDatum<'tcx>>>,
+// Maps the DefId's for local variables to the allocas created for
+// them in llallocas.
+pub lllocals: RefCell<NodeMap<LvalueDatum<'tcx>>>,
- // Same as above, but for closure upvars
- pub llupvars: RefCell<NodeMap<ValueRef>>,
+// Same as above, but for closure upvars
+pub llupvars: RefCell<NodeMap<ValueRef>>,
- // The NodeId of the function, or -1 if it doesn't correspond to
- // a user-defined function.
- pub id: ast::NodeId,
+// The NodeId of the function, or -1 if it doesn't correspond to
+// a user-defined function.
+pub id: ast::NodeId,
- // If this function is being monomorphized, this contains the type
- // substitutions used.
- pub param_substs: &'a Substs<'tcx>,
+// If this function is being monomorphized, this contains the type
+// substitutions used.
+pub param_substs: &'a Substs<'tcx>,
- // The source span and nesting context where this function comes from, for
- // error reporting and symbol generation.
- pub span: Option<Span>,
+// The source span and nesting context where this function comes from, for
+// error reporting and symbol generation.
+pub span: Option<Span>,
- // The arena that blocks are allocated from.
- pub block_arena: &'a TypedArena<BlockS<'a, 'tcx>>,
+// The arena that blocks are allocated from.
+pub block_arena: &'a TypedArena<BlockS<'a, 'tcx>>,
- // This function's enclosing crate context.
- pub ccx: &'a CrateContext<'a, 'tcx>,
+// This function's enclosing crate context.
+pub ccx: &'a CrateContext<'a, 'tcx>,
- // Used and maintained by the debuginfo module.
- pub debug_context: debuginfo::FunctionDebugContext,
+// Used and maintained by the debuginfo module.
+pub debug_context: debuginfo::FunctionDebugContext,
- // Cleanup scopes.
- pub scopes: RefCell<Vec<cleanup::CleanupScope<'a, 'tcx>>>,
+// Cleanup scopes.
+pub scopes: RefCell<Vec<cleanup::CleanupScope<'a, 'tcx>>>,
- pub cfg: Option<cfg::CFG>,
+pub cfg: Option<cfg::CFG>,
}
impl<'a, 'tcx> FunctionContext<'a, 'tcx> {
- pub fn arg_pos(&self, arg: uint) -> uint {
- let arg = self.env_arg_pos() + arg;
- if self.llenv.is_some() {
- arg + 1
- } else {
- arg
- }
+pub fn arg_pos(&self, arg: uint) -> uint {
+ let arg = self.env_arg_pos() + arg;
+ if self.llenv.is_some() {
+ arg + 1
+ } else {
+ arg
}
+}
- pub fn env_arg_pos(&self) -> uint {
- if self.caller_expects_out_pointer {
- 1u
- } else {
- 0u
- }
+pub fn env_arg_pos(&self) -> uint {
+ if self.caller_expects_out_pointer {
+ 1u
+ } else {
+ 0u
}
+}
- pub fn cleanup(&self) {
- unsafe {
- llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt
- .get()
- .unwrap());
- }
+pub fn cleanup(&self) {
+ unsafe {
+ llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt
+ .get()
+ .unwrap());
}
+}
- pub fn get_llreturn(&self) -> BasicBlockRef {
- if self.llreturn.get().is_none() {
-
- self.llreturn.set(Some(unsafe {
- llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), self.llfn,
- "return\0".as_ptr() as *const _)
- }))
- }
+pub fn get_llreturn(&self) -> BasicBlockRef {
+ if self.llreturn.get().is_none() {
- self.llreturn.get().unwrap()
+ self.llreturn.set(Some(unsafe {
+ llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), self.llfn,
+ "return\0".as_ptr() as *const _)
+ }))
}
- pub fn get_ret_slot(&self, bcx: Block<'a, 'tcx>,
- output: ty::FnOutput<'tcx>,
- name: &str) -> ValueRef {
- if self.needs_ret_allocas {
- base::alloca_no_lifetime(bcx, match output {
- ty::FnConverging(output_type) => type_of::type_of(bcx.ccx(), output_type),
- ty::FnDiverging => Type::void(bcx.ccx())
- }, name)
- } else {
- self.llretslotptr.get().unwrap()
- }
- }
+ self.llreturn.get().unwrap()
+}
- pub fn new_block(&'a self,
- is_lpad: bool,
- name: &str,
- opt_node_id: Option<ast::NodeId>)
- -> Block<'a, 'tcx> {
- unsafe {
- let name = CString::from_slice(name.as_bytes());
- let llbb = llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(),
- self.llfn,
- name.as_ptr());
- BlockS::new(llbb, is_lpad, opt_node_id, self)
- }
+pub fn get_ret_slot(&self, bcx: Block<'a, 'tcx>,
+ output: ty::FnOutput<'tcx>,
+ name: &str) -> ValueRef {
+ if self.needs_ret_allocas {
+ base::alloca_no_lifetime(bcx, match output {
+ ty::FnConverging(output_type) => type_of::type_of(bcx.ccx(), output_type),
+ ty::FnDiverging => Type::void(bcx.ccx())
+ }, name)
+ } else {
+ self.llretslotptr.get().unwrap()
}
+}
- pub fn new_id_block(&'a self,
- name: &str,
- node_id: ast::NodeId)
- -> Block<'a, 'tcx> {
- self.new_block(false, name, Some(node_id))
+pub fn new_block(&'a self,
+ is_lpad: bool,
+ name: &str,
+ opt_node_id: Option<ast::NodeId>)
+ -> Block<'a, 'tcx> {
+ unsafe {
+ let name = CString::from_slice(name.as_bytes());
+ let llbb = llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(),
+ self.llfn,
+ name.as_ptr());
+ BlockS::new(llbb, is_lpad, opt_node_id, self)
}
+}
- pub fn new_temp_block(&'a self,
- name: &str)
- -> Block<'a, 'tcx> {
- self.new_block(false, name, None)
- }
+pub fn new_id_block(&'a self,
+ name: &str,
+ node_id: ast::NodeId)
+ -> Block<'a, 'tcx> {
+ self.new_block(false, name, Some(node_id))
+}
- pub fn join_blocks(&'a self,
- id: ast::NodeId,
- in_cxs: &[Block<'a, 'tcx>])
- -> Block<'a, 'tcx> {
- let out = self.new_id_block("join", id);
- let mut reachable = false;
- for bcx in in_cxs.iter() {
- if !bcx.unreachable.get() {
- build::Br(*bcx, out.llbb);
- reachable = true;
- }
- }
- if !reachable {
- build::Unreachable(out);
+pub fn new_temp_block(&'a self,
+ name: &str)
+ -> Block<'a, 'tcx> {
+ self.new_block(false, name, None)
+}
+
+pub fn join_blocks(&'a self,
+ id: ast::NodeId,
+ in_cxs: &[Block<'a, 'tcx>])
+ -> Block<'a, 'tcx> {
+ let out = self.new_id_block("join", id);
+ let mut reachable = false;
+ for bcx in in_cxs.iter() {
+ if !bcx.unreachable.get() {
+ build::Br(*bcx, out.llbb);
+ reachable = true;
}
- return out;
}
-
- pub fn monomorphize<T>(&self, value: &T) -> T
- where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
- {
- monomorphize::apply_param_substs(self.ccx.tcx(),
- self.param_substs,
- value)
+ if !reachable {
+ build::Unreachable(out);
}
+ return out;
+}
+
+pub fn monomorphize<T>(&self, value: &T) -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
+{
+ monomorphize::apply_param_substs(self.ccx.tcx(),
+ self.param_substs,
+ value)
+}
}
// Basic block context. We create a block context for each basic block
// with many basic blocks per function. All the basic blocks attached to a
// function are organized as a directed graph.
pub struct BlockS<'blk, 'tcx: 'blk> {
- // The BasicBlockRef returned from a call to
- // llvm::LLVMAppendBasicBlock(llfn, name), which adds a basic
- // block to the function pointed to by llfn. We insert
- // instructions into that block by way of this block context.
- // The block pointing to this one in the function's digraph.
- pub llbb: BasicBlockRef,
- pub terminated: Cell<bool>,
- pub unreachable: Cell<bool>,
+// The BasicBlockRef returned from a call to
+// llvm::LLVMAppendBasicBlock(llfn, name), which adds a basic
+// block to the function pointed to by llfn. We insert
+// instructions into that block by way of this block context.
+// The block pointing to this one in the function's digraph.
+pub llbb: BasicBlockRef,
+pub terminated: Cell<bool>,
+pub unreachable: Cell<bool>,
- // Is this block part of a landing pad?
- pub is_lpad: bool,
+// Is this block part of a landing pad?
+pub is_lpad: bool,
- // AST node-id associated with this block, if any. Used for
- // debugging purposes only.
-
pub opt_node_id: Option<ast::NodeId>,
+// AST node-id associated with this block, if any. Used for
+// debugging purposes only.
+pub opt_node_id: Option<ast::NodeId>,
- // The function context for the function to which this block is
- // attached.
- pub fcx: &'blk FunctionContext<'blk, 'tcx>,
+// The function context for the function to which this block is
+// attached.
+pub fcx: &'blk FunctionContext<'blk, 'tcx>,
}
pub type Block<'blk, 'tcx> = &'blk BlockS<'blk, 'tcx>;
impl<'blk, 'tcx> BlockS<'blk, 'tcx> {
- pub fn new(llbb: BasicBlockRef,
- is_lpad: bool,
-
opt_node_id: Option<ast::NodeId>,
- fcx: &'blk FunctionContext<'blk, 'tcx>)
- -> Block<'blk, 'tcx> {
- fcx.block_arena.alloc(BlockS {
- llbb: llbb,
- terminated: Cell::new(false),
- unreachable: Cell::new(false),
- is_lpad: is_lpad,
- opt_node_id: opt_node_id,
- fcx: fcx
- })
- }
+pub fn new(llbb: BasicBlockRef,
+ is_lpad: bool,
+ opt_node_id: Option<ast::NodeId>,
+ fcx: &'blk FunctionContext<'blk, 'tcx>)
+ -> Block<'blk, 'tcx> {
+ fcx.block_arena.alloc(BlockS {
+ llbb: llbb,
+ terminated: Cell::new(false),
+ unreachable: Cell::new(false),
+ is_lpad: is_lpad,
+ opt_node_id: opt_node_id,
+ fcx: fcx
+ })
+}
- pub fn ccx(&self) -> &'blk CrateContext<'blk, 'tcx> {
- self.fcx.ccx
- }
- pub fn tcx(&self) -> &'blk ty::ctxt<'tcx> {
- self.fcx.ccx.tcx()
- }
- pub fn sess(&self) -> &'blk Session { self.fcx.ccx.sess() }
+pub fn ccx(&self) -> &'blk CrateContext<'blk, 'tcx> {
+ self.fcx.ccx
+}
+pub fn tcx(&self) -> &'blk ty::ctxt<'tcx> {
+ self.fcx.ccx.tcx()
+}
+pub fn sess(&self) -> &'blk Session { self.fcx.ccx.sess() }
- pub fn ident(&self, ident: Ident) -> String {
- token::get_ident(ident).get().to_string()
- }
+pub fn ident(&self, ident: Ident) -> String {
+ token::get_ident(ident).get().to_string()
+}
- pub fn node_id_to_string(&self, id: ast::NodeId) -> String {
- self.tcx().map.node_to_string(id).to_string()
- }
+pub fn node_id_to_string(&self, id: ast::NodeId) -> String {
+ self.tcx().map.node_to_string(id).to_string()
+}
- pub fn expr_to_string(&self, e: &ast::Expr) -> String {
- e.repr(self.tcx())
- }
+pub fn expr_to_string(&self, e: &ast::Expr) -> String {
+ e.repr(self.tcx())
+}
- pub fn def(&self, nid: ast::NodeId) -> def::Def {
- match self.tcx().def_map.borrow().get(&nid) {
- Some(v) => v.clone(),
- None => {
- self.tcx().sess.bug(format!(
- "no def associated with node id {}", nid)[]);
- }
+pub fn def(&self, nid: ast::NodeId) -> def::Def {
+ match self.tcx().def_map.borrow().get(&nid) {
+ Some(v) => v.clone(),
+ None => {
+ self.tcx().sess.bug(format!(
+ "no def associated with node id {}", nid).index(&FullRange));
}
}
+}
- pub fn val_to_string(&self, val: ValueRef) -> String {
- self.ccx().tn().val_to_string(val)
- }
+pub fn val_to_string(&self, val: ValueRef) -> String {
+ self.ccx().tn().val_to_string(val)
+}
- pub fn llty_str(&self, ty: Type) -> String {
- self.ccx().tn().type_to_string(ty)
- }
+pub fn llty_str(&self, ty: Type) -> String {
+ self.ccx().tn().type_to_string(ty)
+}
- pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
- t.repr(self.tcx())
- }
+pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
+ t.repr(self.tcx())
+}
- pub fn to_str(&self) -> String {
- format!("[block {:p}]", self)
- }
+pub fn to_str(&self) -> String {
+ format!("[block {:p}]", self)
+}
- pub fn monomorphize<T>(&self, value: &T) -> T
- where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
- {
- monomorphize::apply_param_substs(self.tcx(),
- self.fcx.param_substs,
- value)
- }
+pub fn monomorphize<T>(&self, value: &T) -> T
+ where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
+{
+ monomorphize::apply_param_substs(self.tcx(),
+ self.fcx.param_substs,
+ value)
+}
}
impl<'blk, 'tcx> mc::Typer<'tcx> for BlockS<'blk, 'tcx> {
- fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> {
- self.tcx()
- }
+fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> {
+ self.tcx()
+}
- fn node_ty(&self, id: ast::NodeId) -> mc::McResult<Ty<'tcx>> {
- Ok(node_id_type(self, id))
- }
+fn node_ty(&self, id: ast::NodeId) -> mc::McResult<Ty<'tcx>> {
+ Ok(node_id_type(self, id))
+}
- fn expr_ty_adjusted(&self, expr: &ast::Expr) -> mc::McResult<Ty<'tcx>> {
- Ok(expr_ty_adjusted(self, expr))
- }
+fn expr_ty_adjusted(&self, expr: &ast::Expr) -> mc::McResult<Ty<'tcx>> {
+ Ok(expr_ty_adjusted(self, expr))
+}
- fn node_method_ty(&self, method_call: ty::MethodCall) -> Option<Ty<'tcx>> {
- self.tcx()
- .method_map
- .borrow()
- .get(&method_call)
- .map(|method| monomorphize_type(self, method.ty))
- }
+fn node_method_ty(&self, method_call: ty::MethodCall) -> Option<Ty<'tcx>> {
+ self.tcx()
+ .method_map
+ .borrow()
+ .get(&method_call)
+ .map(|method| monomorphize_type(self, method.ty))
+}
- fn node_method_origin(&self, method_call: ty::MethodCall)
- -> Option<ty::MethodOrigin<'tcx>>
- {
- self.tcx()
- .method_map
- .borrow()
- .get(&method_call)
- .map(|method| method.origin.clone())
- }
+fn node_method_origin(&self, method_call: ty::MethodCall)
+ -> Option<ty::MethodOrigin<'tcx>>
+{
+ self.tcx()
+ .method_map
+ .borrow()
+ .get(&method_call)
+ .map(|method| method.origin.clone())
+}
- fn adjustments<'a>(&'a self) -> &'a RefCell<NodeMap<ty::AutoAdjustment<'tcx>>> {
- &self.tcx().adjustments
- }
+fn adjustments<'a>(&'a self) -> &'a RefCell<NodeMap<ty::AutoAdjustment<'tcx>>> {
+ &self.tcx().adjustments
+}
- fn is_method_call(&self, id: ast::NodeId) -> bool {
- self.tcx().method_map.borrow().contains_key(&ty::MethodCall::expr(id))
- }
+fn is_method_call(&self, id: ast::NodeId) -> bool {
+ self.tcx().method_map.borrow().contains_key(&ty::MethodCall::expr(id))
+}
- fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> {
- self.tcx().region_maps.temporary_scope(rvalue_id)
- }
+fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<region::CodeExtent> {
+ self.tcx().region_maps.temporary_scope(rvalue_id)
+}
- fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> Option<ty::UpvarBorrow> {
- Some(self.tcx().upvar_borrow_map.borrow()[upvar_id].clone())
- }
+fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> Option<ty::UpvarBorrow> {
+ Some(self.tcx().upvar_borrow_map.borrow()[upvar_id].clone())
+}
- fn capture_mode(&self, closure_expr_id: ast::NodeId)
- -> ast::CaptureClause {
- self.tcx().capture_modes.borrow()[closure_expr_id].clone()
- }
+fn capture_mode(&self, closure_expr_id: ast::NodeId)
+ -> ast::CaptureClause {
+ self.tcx().capture_modes.borrow()[closure_expr_id].clone()
+}
- fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool {
- self.fcx.param_env.type_moves_by_default(span, ty)
- }
+fn type_moves_by_default(&self, span: Span, ty: Ty<'tcx>) -> bool {
+ self.fcx.param_env.type_moves_by_default(span, ty)
+}
}
impl<'blk, 'tcx> ty::UnboxedClosureTyper<'tcx> for BlockS<'blk, 'tcx> {
- fn param_env<'a>(&'a self) -> &'a ty::ParameterEnvironment<'a, 'tcx> {
- &self.fcx.param_env
- }
+fn param_env<'a>(&'a self) -> &'a ty::ParameterEnvironment<'a, 'tcx> {
+ &self.fcx.param_env
+}
- fn unboxed_closure_kind(&self,
- def_id: ast::DefId)
- -> ty::UnboxedClosureKind
- {
- let typer = NormalizingUnboxedClosureTyper::new(self.tcx());
- typer.unboxed_closure_kind(def_id)
- }
+fn unboxed_closure_kind(&self,
+ def_id: ast::DefId)
+ -> ty::UnboxedClosureKind
+{
+ let typer = NormalizingUnboxedClosureTyper::new(self.tcx());
+ typer.unboxed_closure_kind(def_id)
+}
- fn unboxed_closure_type(&self,
- def_id: ast::DefId,
- substs: &subst::Substs<'tcx>)
- -> ty::ClosureTy<'tcx>
- {
- let typer = NormalizingUnboxedClosureTyper::new(self.tcx());
- typer.unboxed_closure_type(def_id, substs)
- }
+fn unboxed_closure_type(&self,
+ def_id: ast::DefId,
+ substs: &subst::Substs<'tcx>)
+ -> ty::ClosureTy<'tcx>
+{
+ let typer = NormalizingUnboxedClosureTyper::new(self.tcx());
+ typer.unboxed_closure_type(def_id, substs)
+}
- fn unboxed_closure_upvars(&self,
- def_id: ast::DefId,
- substs: &Substs<'tcx>)
- -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>>
- {
- let typer = NormalizingUnboxedClosureTyper::new(self.tcx());
- typer.unboxed_closure_upvars(def_id, substs)
- }
+fn unboxed_closure_upvars(&self,
+ def_id: ast::DefId,
+ substs: &Substs<'tcx>)
+ -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>>
+{
+ let typer = NormalizingUnboxedClosureTyper::new(self.tcx());
+ typer.unboxed_closure_upvars(def_id, substs)
+}
}
pub struct Result<'blk, 'tcx: 'blk> {
- pub bcx: Block<'blk, 'tcx>,
- pub val: ValueRef
+pub bcx: Block<'blk, 'tcx>,
+pub val: ValueRef
}
impl<'b, 'tcx> Result<'b, 'tcx> {
- pub fn new(bcx: Block<'b, 'tcx>, val: ValueRef) -> Result<'b, 'tcx> {
- Result {
- bcx: bcx,
- val: val,
- }
+pub fn new(bcx: Block<'b, 'tcx>, val: ValueRef) -> Result<'b, 'tcx> {
+ Result {
+ bcx: bcx,
+ val: val,
}
}
+}
pub fn val_ty(v: ValueRef) -> Type {
- unsafe {
- Type::from_ref(llvm::LLVMTypeOf(v))
- }
+unsafe {
+ Type::from_ref(llvm::LLVMTypeOf(v))
+}
}
// LLVM constant constructors.
pub fn C_null(t: Type) -> ValueRef {
- unsafe {
- llvm::LLVMConstNull(t.to_ref())
- }
+unsafe {
+ llvm::LLVMConstNull(t.to_ref())
+}
}
pub fn C_undef(t: Type) -> ValueRef {
- unsafe {
- llvm::LLVMGetUndef(t.to_ref())
- }
+unsafe {
+ llvm::LLVMGetUndef(t.to_ref())
+}
}
pub fn C_integral(t: Type, u: u64, sign_extend: bool) -> ValueRef {
- unsafe {
- llvm::LLVMConstInt(t.to_ref(), u, sign_extend as Bool)
- }
+unsafe {
+ llvm::LLVMConstInt(t.to_ref(), u, sign_extend as Bool)
+}
}
pub fn C_floating(s: &str, t: Type) -> ValueRef {
- unsafe {
- let s = CString::from_slice(s.as_bytes());
- llvm::LLVMConstRealOfString(t.to_ref(), s.as_ptr())
- }
+unsafe {
+ let s = CString::from_slice(s.as_bytes());
+ llvm::LLVMConstRealOfString(t.to_ref(), s.as_ptr())
+}
}
pub fn C_nil(ccx: &CrateContext) -> ValueRef {
- C_struct(ccx, &[], false)
+C_struct(ccx, &[], false)
}
pub fn C_bool(ccx: &CrateContext, val: bool) -> ValueRef {
- C_integral(Type::i1(ccx), val as u64, false)
+C_integral(Type::i1(ccx), val as u64, false)
}
pub fn C_i32(ccx: &CrateContext, i: i32) -> ValueRef {
- C_integral(Type::i32(ccx), i as u64, true)
+C_integral(Type::i32(ccx), i as u64, true)
}
pub fn C_i64(ccx: &CrateContext, i: i64) -> ValueRef {
- C_integral(Type::i64(ccx), i as u64, true)
+C_integral(Type::i64(ccx), i as u64, true)
}
pub fn C_u64(ccx: &CrateContext, i: u64) -> ValueRef {
- C_integral(Type::i64(ccx), i, false)
+C_integral(Type::i64(ccx), i, false)
}
pub fn C_int<I: AsI64>(ccx: &CrateContext, i: I) -> ValueRef {
- let v = i.as_i64();
+let v = i.as_i64();
- match machine::llbitsize_of_real(ccx, ccx.int_type()) {
- 32 => assert!(v < (1<<31) && v >= -(1<<31)),
- 64 => {},
- n => panic!("unsupported target size: {}", n)
- }
+match machine::llbitsize_of_real(ccx, ccx.int_type()) {
+ 32 => assert!(v < (1<<31) && v >= -(1<<31)),
+ 64 => {},
+ n => panic!("unsupported target size: {}", n)
+}
- C_integral(ccx.int_type(), v as u64, true)
+C_integral(ccx.int_type(), v as u64, true)
}
pub fn C_uint<I: AsU64>(ccx: &CrateContext, i: I) -> ValueRef {
- let v = i.as_u64();
+let v = i.as_u64();
- match machine::llbitsize_of_real(ccx, ccx.int_type()) {
- 32 => assert!(v < (1<<32)),
- 64 => {},
- n => panic!("unsupported target size: {}", n)
- }
+match machine::llbitsize_of_real(ccx, ccx.int_type()) {
+ 32 => assert!(v < (1<<32)),
+ 64 => {},
+ n => panic!("unsupported target size: {}", n)
+}
- C_integral(ccx.int_type(), v, false)
+C_integral(ccx.int_type(), v, false)
}
pub trait AsI64 { fn as_i64(self) -> i64; }
impl AsU64 for uint { fn as_u64(self) -> u64 { self as u64 }}
pub fn C_u8(ccx: &CrateContext, i: uint) -> ValueRef {
- C_integral(Type::i8(ccx), i as u64, false)
+C_integral(Type::i8(ccx), i as u64, false)
}
// This is a 'c-like' raw string, which differs from
// our boxed-and-length-annotated strings.
pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef {
- unsafe {
- match cx.const_cstr_cache().borrow().get(&s) {
- Some(&llval) => return llval,
- None => ()
- }
+unsafe {
+ match cx.const_cstr_cache().borrow().get(&s) {
+ Some(&llval) => return llval,
+ None => ()
+ }
- let sc = llvm::LLVMConstStringInContext(cx.llcx(),
- s.get().as_ptr() as *const c_char,
- s.get().len() as c_uint,
- !null_terminated as Bool);
+ let sc = llvm::LLVMConstStringInContext(cx.llcx(),
+ s.get().as_ptr() as *const c_char,
+ s.get().len() as c_uint,
+ !null_terminated as Bool);
- let gsym = token::gensym("str");
- let buf = CString::from_vec(format!("str{}", gsym.uint()).into_bytes());
- let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(sc).to_ref(), buf.as_ptr());
- llvm::LLVMSetInitializer(g, sc);
- llvm::LLVMSetGlobalConstant(g, True);
- llvm::SetLinkage(g, llvm::InternalLinkage);
+ let gsym = token::gensym("str");
+ let buf = CString::from_vec(format!("str{}", gsym.uint()).into_bytes());
+ let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(sc).to_ref(), buf.as_ptr());
+ llvm::LLVMSetInitializer(g, sc);
+ llvm::LLVMSetGlobalConstant(g, True);
+ llvm::SetLinkage(g, llvm::InternalLinkage);
- cx.const_cstr_cache().borrow_mut().insert(s, g);
- g
- }
+ cx.const_cstr_cache().borrow_mut().insert(s, g);
+ g
+}
}
// NB: Do not use `do_spill_noroot` to make this into a constant string, or
// you will be kicked off fast isel. See issue #4352 for an example of this.
pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
- let len = s.get().len();
- let cs = consts::ptrcast(C_cstr(cx, s, false), Type::i8p(cx));
- C_named_struct(cx.tn().find_type("str_slice").unwrap(), &[cs, C_uint(cx, len)])
+let len = s.get().len();
+let cs = consts::ptrcast(C_cstr(cx, s, false), Type::i8p(cx));
+C_named_struct(cx.tn().find_type("str_slice").unwrap(), &[cs, C_uint(cx, len)])
}
pub fn C_binary_slice(cx: &CrateContext, data: &[u8]) -> ValueRef {
- unsafe {
- let len = data.len();
- let lldata = C_bytes(cx, data);
-
- let gsym = token::gensym("binary");
- let name = format!("binary{}", gsym.uint());
- let name = CString::from_vec(name.into_bytes());
- let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(lldata).to_ref(),
- name.as_ptr());
- llvm::LLVMSetInitializer(g, lldata);
- llvm::LLVMSetGlobalConstant(g, True);
- llvm::SetLinkage(g, llvm::InternalLinkage);
-
- let cs = consts::ptrcast(g, Type::i8p(cx));
- C_struct(cx, &[cs, C_uint(cx, len)], false)
- }
+unsafe {
+ let len = data.len();
+ let lldata = C_bytes(cx, data);
+
+ let gsym = token::gensym("binary");
+ let name = format!("binary{}", gsym.uint());
+ let name = CString::from_vec(name.into_bytes());
+ let g = llvm::LLVMAddGlobal(cx.llmod(), val_ty(lldata).to_ref(),
+ name.as_ptr());
+ llvm::LLVMSetInitializer(g, lldata);
+ llvm::LLVMSetGlobalConstant(g, True);
+ llvm::SetLinkage(g, llvm::InternalLinkage);
+
+ let cs = consts::ptrcast(g, Type::i8p(cx));
+ C_struct(cx, &[cs, C_uint(cx, len)], false)
+}
}
pub fn C_struct(cx: &CrateContext, elts: &[ValueRef], packed: bool) -> ValueRef {
- C_struct_in_context(cx.llcx(), elts, packed)
+C_struct_in_context(cx.llcx(), elts, packed)
}
pub fn C_struct_in_context(llcx: ContextRef, elts: &[ValueRef], packed: bool) -> ValueRef {
- unsafe {
- llvm::LLVMConstStructInContext(llcx,
- elts.as_ptr(), elts.len() as c_uint,
- packed as Bool)
- }
+unsafe {
+ llvm::LLVMConstStructInContext(llcx,
+ elts.as_ptr(), elts.len() as c_uint,
+ packed as Bool)
+}
}
pub fn C_named_struct(t: Type, elts: &[ValueRef]) -> ValueRef {
- unsafe {
- llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint)
- }
+unsafe {
+ llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint)
+}
}
pub fn C_array(ty: Type, elts: &[ValueRef]) -> ValueRef {
- unsafe {
- return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint);
- }
+unsafe {
+ return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint);
+}
}
pub fn C_bytes(cx: &CrateContext, bytes: &[u8]) -> ValueRef {
- C_bytes_in_context(cx.llcx(), bytes)
+C_bytes_in_context(cx.llcx(), bytes)
}
pub fn C_bytes_in_context(llcx: ContextRef, bytes: &[u8]) -> ValueRef {
- unsafe {
- let ptr = bytes.as_ptr() as *const c_char;
- return llvm::LLVMConstStringInContext(llcx, ptr, bytes.len() as c_uint, True);
- }
+unsafe {
+ let ptr = bytes.as_ptr() as *const c_char;
+ return llvm::LLVMConstStringInContext(llcx, ptr, bytes.len() as c_uint, True);
+}
}
pub fn const_get_elt(cx: &CrateContext, v: ValueRef, us: &[c_uint])
- -> ValueRef {
- unsafe {
- let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint);
+ -> ValueRef {
+unsafe {
+ let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint);
- debug!("const_get_elt(v={}, us={}, r={})",
- cx.tn().val_to_string(v), us, cx.tn().val_to_string(r));
+ debug!("const_get_elt(v={}, us={:?}, r={})",
+ cx.tn().val_to_string(v), us, cx.tn().val_to_string(r));
- return r;
- }
+ return r;
+}
}
pub fn is_const(v: ValueRef) -> bool {
- unsafe {
- llvm::LLVMIsConstant(v) == True
- }
+unsafe {
+ llvm::LLVMIsConstant(v) == True
+}
}
pub fn const_to_int(v: ValueRef) -> i64 {
- unsafe {
- llvm::LLVMConstIntGetSExtValue(v)
- }
+unsafe {
+ llvm::LLVMConstIntGetSExtValue(v)
+}
}
pub fn const_to_uint(v: ValueRef) -> u64 {
- unsafe {
- llvm::LLVMConstIntGetZExtValue(v)
- }
+unsafe {
+ llvm::LLVMConstIntGetZExtValue(v)
+}
}
pub fn is_undef(val: ValueRef) -> bool {
- unsafe {
- llvm::LLVMIsUndef(val) != False
- }
+unsafe {
+ llvm::LLVMIsUndef(val) != False
+}
}
#[allow(dead_code)] // potentially useful
pub fn is_null(val: ValueRef) -> bool {
- unsafe {
- llvm::LLVMIsNull(val) != False
- }
+unsafe {
+ llvm::LLVMIsNull(val) != False
+}
}
pub fn monomorphize_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, t: Ty<'tcx>) -> Ty<'tcx> {
- bcx.fcx.monomorphize(&t)
+bcx.fcx.monomorphize(&t)
}
pub fn node_id_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, id: ast::NodeId) -> Ty<'tcx> {
- let tcx = bcx.tcx();
- let t = ty::node_id_to_type(tcx, id);
- monomorphize_type(bcx, t)
+let tcx = bcx.tcx();
+let t = ty::node_id_to_type(tcx, id);
+monomorphize_type(bcx, t)
}
pub fn expr_ty<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &ast::Expr) -> Ty<'tcx> {
- node_id_type(bcx, ex.id)
+node_id_type(bcx, ex.id)
}
pub fn expr_ty_adjusted<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &ast::Expr) -> Ty<'tcx> {
- monomorphize_type(bcx, ty::expr_ty_adjusted(bcx.tcx(), ex))
+monomorphize_type(bcx, ty::expr_ty_adjusted(bcx.tcx(), ex))
}
/// Attempts to resolve an obligation. The result is a shallow vtable resolution -- meaning that we
/// do not (necessarily) resolve all nested obligations on the impl. Note that type check should
/// guarantee to us that all nested obligations *could be* resolved if we wanted to.
pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- span: Span,
- trait_ref: ty::PolyTraitRef<'tcx>)
- -> traits::Vtable<'tcx, ()>
+ span: Span,
+ trait_ref: ty::PolyTraitRef<'tcx>)
+ -> traits::Vtable<'tcx, ()>
{
- let tcx = ccx.tcx();
-
- // Remove any references to regions; this helps improve caching.
- let trait_ref = ty_fold::erase_regions(tcx, trait_ref);
-
- // First check the cache.
- match ccx.trait_cache().borrow().get(&trait_ref) {
- Some(vtable) => {
- info!("Cache hit: {}", trait_ref.repr(ccx.tcx()));
- return (*vtable).clone();
- }
- None => { }
- }
-
- debug!("trans fulfill_obligation: trait_ref={}", trait_ref.repr(ccx.tcx()));
-
- ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id());
- let infcx = infer::new_infer_ctxt(tcx);
-
- // Do the initial selection for the obligation. This yields the
- // shallow result we are looking for -- that is, what specific impl.
- let typer = NormalizingUnboxedClosureTyper::new(tcx);
- let mut selcx = traits::SelectionContext::new(&infcx, &typer);
- let obligation = traits::Obligation::new(traits::ObligationCause::dummy(),
- trait_ref.to_poly_trait_predicate());
- let selection = match selcx.select(&obligation) {
- Ok(Some(selection)) => selection,
- Ok(None) => {
- // Ambiguity can happen when monomorphizing during trans
- // expands to some humongo type that never occurred
- // statically -- this humongo type can then overflow,
- // leading to an ambiguous result. So report this as an
- // overflow bug, since I believe this is the only case
- // where ambiguity can result.
- debug!("Encountered ambiguity selecting `{}` during trans, \
- presuming due to overflow",
- trait_ref.repr(tcx));
- ccx.sess().span_fatal(
- span,
- "reached the recursion limit during monomorphization");
- }
- Err(e) => {
- tcx.sess.span_bug(
- span,
- format!("Encountered error `{}` selecting `{}` during trans",
- e.repr(tcx),
- trait_ref.repr(tcx))[])
- }
- };
-
- // Currently, we use a fulfillment context to completely resolve
- // all nested obligations. This is because they can inform the
- // inference of the impl's type parameters.
- let mut fulfill_cx = traits::FulfillmentContext::new();
- let vtable = selection.map_move_nested(|predicate| {
- fulfill_cx.register_predicate_obligation(&infcx, predicate);
- });
- let vtable = drain_fulfillment_cx(span, &infcx, &mut fulfill_cx, &vtable);
-
- info!("Cache miss: {}", trait_ref.repr(ccx.tcx()));
- ccx.trait_cache().borrow_mut().insert(trait_ref,
- vtable.clone());
-
- vtable
+let tcx = ccx.tcx();
+
+// Remove any references to regions; this helps improve caching.
+let trait_ref = ty_fold::erase_regions(tcx, trait_ref);
+
+// First check the cache.
+match ccx.trait_cache().borrow().get(&trait_ref) {
+ Some(vtable) => {
+ info!("Cache hit: {}", trait_ref.repr(ccx.tcx()));
+ return (*vtable).clone();
+ }
+ None => { }
+}
+
+debug!("trans fulfill_obligation: trait_ref={}", trait_ref.repr(ccx.tcx()));
+
+ty::populate_implementations_for_trait_if_necessary(tcx, trait_ref.def_id());
+let infcx = infer::new_infer_ctxt(tcx);
+
+// Do the initial selection for the obligation. This yields the
+// shallow result we are looking for -- that is, what specific impl.
+let typer = NormalizingUnboxedClosureTyper::new(tcx);
+let mut selcx = traits::SelectionContext::new(&infcx, &typer);
+let obligation = traits::Obligation::new(traits::ObligationCause::dummy(),
+ trait_ref.to_poly_trait_predicate());
+let selection = match selcx.select(&obligation) {
+ Ok(Some(selection)) => selection,
+ Ok(None) => {
+ // Ambiguity can happen when monomorphizing during trans
+ // expands to some humongo type that never occurred
+ // statically -- this humongo type can then overflow,
+ // leading to an ambiguous result. So report this as an
+ // overflow bug, since I believe this is the only case
+ // where ambiguity can result.
+ debug!("Encountered ambiguity selecting `{}` during trans, \
+ presuming due to overflow",
+ trait_ref.repr(tcx));
+ ccx.sess().span_fatal(
+ span,
+ "reached the recursion limit during monomorphization");
+ }
+ Err(e) => {
+ tcx.sess.span_bug(
+ span,
+ format!("Encountered error `{}` selecting `{}` during trans",
+ e.repr(tcx),
+ trait_ref.repr(tcx)).index(&FullRange))
+ }
+};
+
+// Currently, we use a fulfillment context to completely resolve
+// all nested obligations. This is because they can inform the
+// inference of the impl's type parameters.
+let mut fulfill_cx = traits::FulfillmentContext::new();
+let vtable = selection.map_move_nested(|predicate| {
+ fulfill_cx.register_predicate_obligation(&infcx, predicate);
+});
+let vtable = drain_fulfillment_cx(span, &infcx, &mut fulfill_cx, &vtable);
+
+info!("Cache miss: {}", trait_ref.repr(ccx.tcx()));
+ccx.trait_cache().borrow_mut().insert(trait_ref,
+ vtable.clone());
+
+vtable
}
pub struct NormalizingUnboxedClosureTyper<'a,'tcx:'a> {
- param_env: ty::ParameterEnvironment<'a, 'tcx>
+param_env: ty::ParameterEnvironment<'a, 'tcx>
}
impl<'a,'tcx> NormalizingUnboxedClosureTyper<'a,'tcx> {
- pub fn new(tcx: &'a ty::ctxt<'tcx>) -> NormalizingUnboxedClosureTyper<'a,'tcx> {
- // Parameter environment is used to give details about type parameters,
- // but since we are in trans, everything is fully monomorphized.
- NormalizingUnboxedClosureTyper { param_env: ty::empty_parameter_environment(tcx) }
- }
+pub fn new(tcx: &'a ty::ctxt<'tcx>) -> NormalizingUnboxedClosureTyper<'a,'tcx> {
+ // Parameter environment is used to give details about type parameters,
+ // but since we are in trans, everything is fully monomorphized.
+ NormalizingUnboxedClosureTyper { param_env: ty::empty_parameter_environment(tcx) }
+}
}
impl<'a,'tcx> ty::UnboxedClosureTyper<'tcx> for NormalizingUnboxedClosureTyper<'a,'tcx> {
- fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> {
- &self.param_env
- }
+fn param_env<'b>(&'b self) -> &'b ty::ParameterEnvironment<'b,'tcx> {
+ &self.param_env
+}
- fn unboxed_closure_kind(&self,
- def_id: ast::DefId)
- -> ty::UnboxedClosureKind
- {
- self.param_env.tcx.unboxed_closure_kind(def_id)
- }
+fn unboxed_closure_kind(&self,
+ def_id: ast::DefId)
+ -> ty::UnboxedClosureKind
+{
+ self.param_env.tcx.unboxed_closure_kind(def_id)
+}
- fn unboxed_closure_type(&self,
- def_id: ast::DefId,
- substs: &subst::Substs<'tcx>)
- -> ty::ClosureTy<'tcx>
- {
- // the substitutions in `substs` are already monomorphized,
- // but we still must normalize associated types
- let closure_ty = self.param_env.tcx.unboxed_closure_type(def_id, substs);
- monomorphize::normalize_associated_type(self.param_env.tcx, &closure_ty)
- }
+fn unboxed_closure_type(&self,
+ def_id: ast::DefId,
+ substs: &subst::Substs<'tcx>)
+ -> ty::ClosureTy<'tcx>
+{
+ // the substitutions in `substs` are already monomorphized,
+ // but we still must normalize associated types
+ let closure_ty = self.param_env.tcx.unboxed_closure_type(def_id, substs);
+ monomorphize::normalize_associated_type(self.param_env.tcx, &closure_ty)
+}
- fn unboxed_closure_upvars(&self,
- def_id: ast::DefId,
- substs: &Substs<'tcx>)
- -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>>
- {
- // the substitutions in `substs` are already monomorphized,
- // but we still must normalize associated types
- let result = ty::unboxed_closure_upvars(&self.param_env, def_id, substs);
- monomorphize::normalize_associated_type(self.param_env.tcx, &result)
- }
+fn unboxed_closure_upvars(&self,
+ def_id: ast::DefId,
+ substs: &Substs<'tcx>)
+ -> Option<Vec<ty::UnboxedClosureUpvar<'tcx>>>
+{
+ // the substitutions in `substs` are already monomorphized,
+ // but we still must normalize associated types
+ let result = ty::unboxed_closure_upvars(&self.param_env, def_id, substs);
+ monomorphize::normalize_associated_type(self.param_env.tcx, &result)
+}
}
pub fn drain_fulfillment_cx<'a,'tcx,T>(span: Span,
- infcx: &infer::InferCtxt<'a,'tcx>,
- fulfill_cx: &mut traits::FulfillmentContext<'tcx>,
- result: &T)
- -> T
- where T : TypeFoldable<'tcx> + Repr<'tcx>
+ infcx: &infer::InferCtxt<'a,'tcx>,
+ fulfill_cx: &mut traits::FulfillmentContext<'tcx>,
+ result: &T)
+ -> T
+where T : TypeFoldable<'tcx> + Repr<'tcx>
{
- debug!("drain_fulfillment_cx(result={})",
- result.repr(infcx.tcx));
-
- // In principle, we only need to do this so long as `result`
- // contains unbound type parameters. It could be a slight
- // optimization to stop iterating early.
- let typer = NormalizingUnboxedClosureTyper::new(infcx.tcx);
- match fulfill_cx.select_all_or_error(infcx, &typer) {
- Ok(()) => { }
- Err(errors) => {
- if errors.iter().all(|e| e.is_overflow()) {
- // See Ok(None) case above.
- infcx.tcx.sess.span_fatal(
- span,
- "reached the recursion limit during monomorphization");
- } else {
- infcx.tcx.sess.span_bug(
- span,
- format!("Encountered errors `{}` fulfilling during trans",
- errors.repr(infcx.tcx))[]);
- }
+debug!("drain_fulfillment_cx(result={})",
+ result.repr(infcx.tcx));
+
+// In principle, we only need to do this so long as `result`
+// contains unbound type parameters. It could be a slight
+// optimization to stop iterating early.
+let typer = NormalizingUnboxedClosureTyper::new(infcx.tcx);
+match fulfill_cx.select_all_or_error(infcx, &typer) {
+ Ok(()) => { }
+ Err(errors) => {
+ if errors.iter().all(|e| e.is_overflow()) {
+ // See Ok(None) case above.
+ infcx.tcx.sess.span_fatal(
+ span,
+ "reached the recursion limit during monomorphization");
+ } else {
+ infcx.tcx.sess.span_bug(
+ span,
+ format!("Encountered errors `{}` fulfilling during trans",
+ errors.repr(infcx.tcx)).index(&FullRange));
}
}
+}
- // Use freshen to simultaneously replace all type variables with
- // their bindings and replace all regions with 'static. This is
- // sort of overkill because we do not expect there to be any
- // unbound type variables, hence no `TyFresh` types should ever be
- // inserted.
- result.fold_with(&mut infcx.freshener())
+// Use freshen to simultaneously replace all type variables with
+// their bindings and replace all regions with 'static. This is
+// sort of overkill because we do not expect there to be any
+// unbound type variables, hence no `TyFresh` types should ever be
+// inserted.
+result.fold_with(&mut infcx.freshener())
}
// Key used to lookup values supplied for type parameters in an expr.
#[derive(Copy, PartialEq, Show)]
pub enum ExprOrMethodCall {
- // Type parameters for a path like `None::<int>`
- ExprId(ast::NodeId),
+// Type parameters for a path like `None::<int>`
+ExprId(ast::NodeId),
- // Type parameters for a method call like `a.foo::<int>()`
- MethodCallKey(ty::MethodCall)
+// Type parameters for a method call like `a.foo::<int>()`
+MethodCallKey(ty::MethodCall)
}
pub fn node_id_substs<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- node: ExprOrMethodCall,
- param_substs: &subst::Substs<'tcx>)
- -> subst::Substs<'tcx> {
- let tcx = ccx.tcx();
-
- let substs = match node {
- ExprId(id) => {
- ty::node_id_item_substs(tcx, id).substs
- }
- MethodCallKey(method_call) => {
- (*tcx.method_map.borrow())[method_call].substs.clone()
- }
- };
+ node: ExprOrMethodCall,
+ param_substs: &subst::Substs<'tcx>)
+ -> subst::Substs<'tcx> {
+let tcx = ccx.tcx();
+
+let substs = match node {
+ ExprId(id) => {
+ ty::node_id_item_substs(tcx, id).substs
+ }
+ MethodCallKey(method_call) => {
+ (*tcx.method_map.borrow())[method_call].substs.clone()
+ }
+};
- if substs.types.any(|t| ty::type_needs_infer(*t)) {
- tcx.sess.bug(format!("type parameters for node {} include inference types: {}",
- node, substs.repr(tcx))[]);
+if substs.types.any(|t| ty::type_needs_infer(*t)) {
+ tcx.sess.bug(format!("type parameters for node {:?} include inference types: {:?}",
+ node, substs.repr(tcx)).index(&FullRange));
}
monomorphize::apply_param_substs(tcx,
Err(s) => {
let msg = format!("{} {}", msg, s);
match span {
- Some(span) => bcx.tcx().sess.span_fatal(span, msg[]),
- None => bcx.tcx().sess.fatal(msg[]),
+ Some(span) => bcx.tcx().sess.span_fatal(span, msg.index(&FullRange)),
+ None => bcx.tcx().sess.fatal(msg.index(&FullRange)),
}
}
}
pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit)
-> ValueRef {
let _icx = push_ctxt("trans_lit");
- debug!("const_lit: {}", lit);
+ debug!("const_lit: {:?}", lit);
match lit.node {
ast::LitByte(b) => C_integral(Type::uint_from_ty(cx, ast::TyU8), b as u64, false),
ast::LitChar(i) => C_integral(Type::char(cx), i as u64, false),
_ => cx.sess().span_bug(lit.span,
format!("integer literal has type {} (expected int \
or uint)",
- ty_to_string(cx.tcx(), lit_int_ty))[])
+ ty_to_string(cx.tcx(), lit_int_ty)).index(&FullRange))
}
}
ast::LitFloat(ref fs, t) => {
}
ast::LitBool(b) => C_bool(cx, b),
ast::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()),
- ast::LitBinary(ref data) => C_binary_slice(cx, data[]),
+ ast::LitBinary(ref data) => C_binary_slice(cx, data.index(&FullRange)),
}
}
.collect::<Vec<_>>();
// If the vector contains enums, an LLVM array won't work.
let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
- C_struct(cx, vs[], false)
+ C_struct(cx, vs.index(&FullRange), false)
} else {
- C_array(llunitty, vs[])
+ C_array(llunitty, vs.index(&FullRange))
};
(v, llunitty)
}
}
_ => {
cx.sess().bug(format!("unexpected dereferenceable type {}",
- ty_to_string(cx.tcx(), t))[])
+ ty_to_string(cx.tcx(), t)).index(&FullRange))
}
}
}
None => {
cx.sess().bug(format!("cannot dereference const of type {}",
- ty_to_string(cx.tcx(), t))[])
+ ty_to_string(cx.tcx(), t)).index(&FullRange))
}
}
}
None => { }
Some(adj) => {
match adj {
- ty::AdjustReifyFnPointer(_def_id) => {
+ ty::AdjustReifyFnPointer(_def_id) => {
// FIXME(#19925) once fn item types are
// zero-sized, we'll need to do something here
}
}
_ => cx.sess().span_bug(e.span,
format!("unimplemented type in const unsize: {}",
- ty_to_string(cx.tcx(), ty))[])
+ ty_to_string(cx.tcx(), ty)).index(&FullRange))
}
}
_ => {
cx.sess()
.span_bug(e.span,
format!("unimplemented const \
- autoref {}",
- autoref)[])
+ autoref {:?}",
+ autoref).index(&FullRange))
}
}
}
}
cx.sess().bug(format!("const {} of type {} has size {} instead of {}",
e.repr(cx.tcx()), ty_to_string(cx.tcx(), ety),
- csize, tsize)[]);
+ csize, tsize).index(&FullRange));
}
(llconst, ety_adjusted)
}
_ => cx.sess().span_bug(base.span,
format!("index-expr base must be a vector \
or string type, found {}",
- ty_to_string(cx.tcx(), bt))[])
+ ty_to_string(cx.tcx(), bt)).index(&FullRange))
},
ty::ty_rptr(_, mt) => match mt.ty.sty {
ty::ty_vec(_, Some(u)) => {
_ => cx.sess().span_bug(base.span,
format!("index-expr base must be a vector \
or string type, found {}",
- ty_to_string(cx.tcx(), bt))[])
+ ty_to_string(cx.tcx(), bt)).index(&FullRange))
},
_ => cx.sess().span_bug(base.span,
format!("index-expr base must be a vector \
or string type, found {}",
- ty_to_string(cx.tcx(), bt))[])
+ ty_to_string(cx.tcx(), bt)).index(&FullRange))
};
let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
ast::ExprTup(ref es) => {
let ety = ty::expr_ty(cx.tcx(), e);
let repr = adt::represent_type(cx, ety);
- let vals = map_list(es[]);
- adt::trans_const(cx, &*repr, 0, vals[])
+ let vals = map_list(es.index(&FullRange));
+ adt::trans_const(cx, &*repr, 0, vals.index(&FullRange))
}
ast::ExprStruct(_, ref fs, ref base_opt) => {
let ety = ty::expr_ty(cx.tcx(), e);
}
}
}).collect::<Vec<_>>();
- adt::trans_const(cx, &*repr, discr, cs[])
+ adt::trans_const(cx, &*repr, discr, cs.index(&FullRange))
})
}
ast::ExprVec(ref es) => {
};
let vs: Vec<_> = repeat(const_expr(cx, &**elem).0).take(n).collect();
if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
- C_struct(cx, vs[], false)
+ C_struct(cx, vs.index(&FullRange), false)
} else {
- C_array(llunitty, vs[])
+ C_array(llunitty, vs.index(&FullRange))
}
}
ast::ExprPath(_) => {
Some(def::DefStruct(_)) => {
let ety = ty::expr_ty(cx.tcx(), e);
let repr = adt::represent_type(cx, ety);
- let arg_vals = map_list(args[]);
- adt::trans_const(cx, &*repr, 0, arg_vals[])
+ let arg_vals = map_list(args.index(&FullRange));
+ adt::trans_const(cx, &*repr, 0, arg_vals.index(&FullRange))
}
Some(def::DefVariant(enum_did, variant_did, _)) => {
let ety = ty::expr_ty(cx.tcx(), e);
let vinfo = ty::enum_variant_with_id(cx.tcx(),
enum_did,
variant_did);
- let arg_vals = map_list(args[]);
+ let arg_vals = map_list(args.index(&FullRange));
adt::trans_const(cx,
&*repr,
vinfo.disr_val,
- arg_vals[])
+ arg_vals.index(&FullRange))
}
_ => cx.sess().span_bug(e.span, "expected a struct or variant def")
}
// such as a function name in the module.
// 1. http://llvm.org/bugs/show_bug.cgi?id=11479
let llmod_id = format!("{}.{}.rs", crate_name, i);
- let local_ccx = LocalCrateContext::new(&shared_ccx, llmod_id[]);
+ let local_ccx = LocalCrateContext::new(&shared_ccx, llmod_id.index(&FullRange));
shared_ccx.local_ccxs.push(local_ccx);
}
.target
.target
.data_layout
- []);
+ .index(&FullRange));
let dbg_cx = if shared.tcx.sess.opts.debuginfo != NoDebugInfo {
Some(debuginfo::CrateDebugContext::new(llmod))
/// currently conservatively bounded to 1 << 47 as that is enough to cover the current usable
/// address space on 64-bit ARMv8 and x86_64.
pub fn obj_size_bound(&self) -> u64 {
- match self.sess().target.target.target_word_size[] {
+ match self.sess().target.target.target_word_size.index(&FullRange) {
"32" => 1 << 31,
"64" => 1 << 47,
_ => unreachable!() // error handled by config::build_target_config
pub fn report_overbig_object(&self, obj: Ty<'tcx>) -> ! {
self.sess().fatal(
format!("the type `{}` is too big for the current architecture",
- obj.repr(self.tcx()))[])
+ obj.repr(self.tcx())).index(&FullRange))
}
}
fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef> {
macro_rules! ifn {
- ($name:expr fn() -> $ret:expr) => (
+ ($name:expr, fn() -> $ret:expr) => (
if *key == $name {
let f = base::decl_cdecl_fn(
ccx, $name, Type::func(&[], &$ret),
return Some(f);
}
);
- ($name:expr fn($($arg:expr),*) -> $ret:expr) => (
+ ($name:expr, fn($($arg:expr),*) -> $ret:expr) => (
if *key == $name {
let f = base::decl_cdecl_fn(ccx, $name,
Type::func(&[$($arg),*], &$ret), ty::mk_nil(ccx.tcx()));
let t_f32 = Type::f32(ccx);
let t_f64 = Type::f64(ccx);
- ifn!("llvm.memcpy.p0i8.p0i8.i32" fn(i8p, i8p, t_i32, t_i32, i1) -> void);
- ifn!("llvm.memcpy.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void);
- ifn!("llvm.memmove.p0i8.p0i8.i32" fn(i8p, i8p, t_i32, t_i32, i1) -> void);
- ifn!("llvm.memmove.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void);
- ifn!("llvm.memset.p0i8.i32" fn(i8p, t_i8, t_i32, t_i32, i1) -> void);
- ifn!("llvm.memset.p0i8.i64" fn(i8p, t_i8, t_i64, t_i32, i1) -> void);
-
- ifn!("llvm.trap" fn() -> void);
- ifn!("llvm.debugtrap" fn() -> void);
- ifn!("llvm.frameaddress" fn(t_i32) -> i8p);
-
- ifn!("llvm.powi.f32" fn(t_f32, t_i32) -> t_f32);
- ifn!("llvm.powi.f64" fn(t_f64, t_i32) -> t_f64);
- ifn!("llvm.pow.f32" fn(t_f32, t_f32) -> t_f32);
- ifn!("llvm.pow.f64" fn(t_f64, t_f64) -> t_f64);
-
- ifn!("llvm.sqrt.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.sqrt.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.sin.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.sin.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.cos.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.cos.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.exp.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.exp.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.exp2.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.exp2.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.log.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.log.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.log10.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.log10.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.log2.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.log2.f64" fn(t_f64) -> t_f64);
-
- ifn!("llvm.fma.f32" fn(t_f32, t_f32, t_f32) -> t_f32);
- ifn!("llvm.fma.f64" fn(t_f64, t_f64, t_f64) -> t_f64);
-
- ifn!("llvm.fabs.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.fabs.f64" fn(t_f64) -> t_f64);
-
- ifn!("llvm.floor.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.floor.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.ceil.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.ceil.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.trunc.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.trunc.f64" fn(t_f64) -> t_f64);
-
- ifn!("llvm.rint.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.rint.f64" fn(t_f64) -> t_f64);
- ifn!("llvm.nearbyint.f32" fn(t_f32) -> t_f32);
- ifn!("llvm.nearbyint.f64" fn(t_f64) -> t_f64);
-
- ifn!("llvm.ctpop.i8" fn(t_i8) -> t_i8);
- ifn!("llvm.ctpop.i16" fn(t_i16) -> t_i16);
- ifn!("llvm.ctpop.i32" fn(t_i32) -> t_i32);
- ifn!("llvm.ctpop.i64" fn(t_i64) -> t_i64);
-
- ifn!("llvm.ctlz.i8" fn(t_i8 , i1) -> t_i8);
- ifn!("llvm.ctlz.i16" fn(t_i16, i1) -> t_i16);
- ifn!("llvm.ctlz.i32" fn(t_i32, i1) -> t_i32);
- ifn!("llvm.ctlz.i64" fn(t_i64, i1) -> t_i64);
-
- ifn!("llvm.cttz.i8" fn(t_i8 , i1) -> t_i8);
- ifn!("llvm.cttz.i16" fn(t_i16, i1) -> t_i16);
- ifn!("llvm.cttz.i32" fn(t_i32, i1) -> t_i32);
- ifn!("llvm.cttz.i64" fn(t_i64, i1) -> t_i64);
-
- ifn!("llvm.bswap.i16" fn(t_i16) -> t_i16);
- ifn!("llvm.bswap.i32" fn(t_i32) -> t_i32);
- ifn!("llvm.bswap.i64" fn(t_i64) -> t_i64);
-
- ifn!("llvm.sadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
- ifn!("llvm.sadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
- ifn!("llvm.sadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
- ifn!("llvm.sadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
-
- ifn!("llvm.uadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
- ifn!("llvm.uadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
- ifn!("llvm.uadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
- ifn!("llvm.uadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
-
- ifn!("llvm.ssub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
- ifn!("llvm.ssub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
- ifn!("llvm.ssub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
- ifn!("llvm.ssub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
-
- ifn!("llvm.usub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
- ifn!("llvm.usub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
- ifn!("llvm.usub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
- ifn!("llvm.usub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
-
- ifn!("llvm.smul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
- ifn!("llvm.smul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
- ifn!("llvm.smul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
- ifn!("llvm.smul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
-
- ifn!("llvm.umul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
- ifn!("llvm.umul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
- ifn!("llvm.umul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
- ifn!("llvm.umul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
-
- ifn!("llvm.lifetime.start" fn(t_i64,i8p) -> void);
- ifn!("llvm.lifetime.end" fn(t_i64, i8p) -> void);
-
- ifn!("llvm.expect.i1" fn(i1, i1) -> i1);
- ifn!("llvm.assume" fn(i1) -> void);
+ ifn!("llvm.memcpy.p0i8.p0i8.i32", fn(i8p, i8p, t_i32, t_i32, i1) -> void);
+ ifn!("llvm.memcpy.p0i8.p0i8.i64", fn(i8p, i8p, t_i64, t_i32, i1) -> void);
+ ifn!("llvm.memmove.p0i8.p0i8.i32", fn(i8p, i8p, t_i32, t_i32, i1) -> void);
+ ifn!("llvm.memmove.p0i8.p0i8.i64", fn(i8p, i8p, t_i64, t_i32, i1) -> void);
+ ifn!("llvm.memset.p0i8.i32", fn(i8p, t_i8, t_i32, t_i32, i1) -> void);
+ ifn!("llvm.memset.p0i8.i64", fn(i8p, t_i8, t_i64, t_i32, i1) -> void);
+
+ ifn!("llvm.trap", fn() -> void);
+ ifn!("llvm.debugtrap", fn() -> void);
+ ifn!("llvm.frameaddress", fn(t_i32) -> i8p);
+
+ ifn!("llvm.powi.f32", fn(t_f32, t_i32) -> t_f32);
+ ifn!("llvm.powi.f64", fn(t_f64, t_i32) -> t_f64);
+ ifn!("llvm.pow.f32", fn(t_f32, t_f32) -> t_f32);
+ ifn!("llvm.pow.f64", fn(t_f64, t_f64) -> t_f64);
+
+ ifn!("llvm.sqrt.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.sqrt.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.sin.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.sin.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.cos.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.cos.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.exp.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.exp.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.exp2.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.exp2.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.log.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.log.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.log10.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.log10.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.log2.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.log2.f64", fn(t_f64) -> t_f64);
+
+ ifn!("llvm.fma.f32", fn(t_f32, t_f32, t_f32) -> t_f32);
+ ifn!("llvm.fma.f64", fn(t_f64, t_f64, t_f64) -> t_f64);
+
+ ifn!("llvm.fabs.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.fabs.f64", fn(t_f64) -> t_f64);
+
+ ifn!("llvm.floor.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.floor.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.ceil.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.ceil.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.trunc.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.trunc.f64", fn(t_f64) -> t_f64);
+
+ ifn!("llvm.rint.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.rint.f64", fn(t_f64) -> t_f64);
+ ifn!("llvm.nearbyint.f32", fn(t_f32) -> t_f32);
+ ifn!("llvm.nearbyint.f64", fn(t_f64) -> t_f64);
+
+ ifn!("llvm.ctpop.i8", fn(t_i8) -> t_i8);
+ ifn!("llvm.ctpop.i16", fn(t_i16) -> t_i16);
+ ifn!("llvm.ctpop.i32", fn(t_i32) -> t_i32);
+ ifn!("llvm.ctpop.i64", fn(t_i64) -> t_i64);
+
+ ifn!("llvm.ctlz.i8", fn(t_i8 , i1) -> t_i8);
+ ifn!("llvm.ctlz.i16", fn(t_i16, i1) -> t_i16);
+ ifn!("llvm.ctlz.i32", fn(t_i32, i1) -> t_i32);
+ ifn!("llvm.ctlz.i64", fn(t_i64, i1) -> t_i64);
+
+ ifn!("llvm.cttz.i8", fn(t_i8 , i1) -> t_i8);
+ ifn!("llvm.cttz.i16", fn(t_i16, i1) -> t_i16);
+ ifn!("llvm.cttz.i32", fn(t_i32, i1) -> t_i32);
+ ifn!("llvm.cttz.i64", fn(t_i64, i1) -> t_i64);
+
+ ifn!("llvm.bswap.i16", fn(t_i16) -> t_i16);
+ ifn!("llvm.bswap.i32", fn(t_i32) -> t_i32);
+ ifn!("llvm.bswap.i64", fn(t_i64) -> t_i64);
+
+ ifn!("llvm.sadd.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
+ ifn!("llvm.sadd.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
+ ifn!("llvm.sadd.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
+ ifn!("llvm.sadd.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
+
+ ifn!("llvm.uadd.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
+ ifn!("llvm.uadd.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
+ ifn!("llvm.uadd.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
+ ifn!("llvm.uadd.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
+
+ ifn!("llvm.ssub.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
+ ifn!("llvm.ssub.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
+ ifn!("llvm.ssub.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
+ ifn!("llvm.ssub.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
+
+ ifn!("llvm.usub.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
+ ifn!("llvm.usub.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
+ ifn!("llvm.usub.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
+ ifn!("llvm.usub.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
+
+ ifn!("llvm.smul.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
+ ifn!("llvm.smul.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
+ ifn!("llvm.smul.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
+ ifn!("llvm.smul.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
+
+ ifn!("llvm.umul.with.overflow.i8", fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
+ ifn!("llvm.umul.with.overflow.i16", fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
+ ifn!("llvm.umul.with.overflow.i32", fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
+ ifn!("llvm.umul.with.overflow.i64", fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
+
+ ifn!("llvm.lifetime.start", fn(t_i64,i8p) -> void);
+ ifn!("llvm.lifetime.end", fn(t_i64, i8p) -> void);
+
+ ifn!("llvm.expect.i1", fn(i1, i1) -> i1);
+ ifn!("llvm.assume", fn(i1) -> void);
// Some intrinsics were introduced in later versions of LLVM, but they have
// fallbacks in libc or libm and such. Currently, all of these intrinsics
($name:expr, $cname:ident ($($arg:expr),*) -> $ret:expr) => (
if unsafe { llvm::LLVMVersionMinor() >= 4 } {
// The `if key == $name` is already in ifn!
- ifn!($name fn($($arg),*) -> $ret);
+ ifn!($name, fn($($arg),*) -> $ret);
} else if *key == $name {
let f = base::decl_cdecl_fn(ccx, stringify!($cname),
Type::func(&[$($arg),*], &$ret),
if ccx.sess().opts.debuginfo != NoDebugInfo {
- ifn!("llvm.dbg.declare" fn(Type::metadata(ccx), Type::metadata(ccx)) -> void);
- ifn!("llvm.dbg.value" fn(Type::metadata(ccx), t_i64, Type::metadata(ccx)) -> void);
+ ifn!("llvm.dbg.declare", fn(Type::metadata(ccx), Type::metadata(ccx)) -> void);
+ ifn!("llvm.dbg.value", fn(Type::metadata(ccx), t_i64, Type::metadata(ccx)) -> void);
}
return None;
}
debug!("trans_stmt({})", s.repr(cx.tcx()));
if cx.sess().asm_comments() {
- add_span_comment(cx, s.span, s.repr(cx.tcx())[]);
+ add_span_comment(cx, s.span, s.repr(cx.tcx()).index(&FullRange));
}
let mut bcx = cx;
}
let name = format!("then-block-{}-", thn.id);
- let then_bcx_in = bcx.fcx.new_id_block(name[], thn.id);
+ let then_bcx_in = bcx.fcx.new_id_block(name.index(&FullRange), thn.id);
let then_bcx_out = trans_block(then_bcx_in, &*thn, dest);
trans::debuginfo::clear_source_location(bcx.fcx);
pat: &ast::Pat,
head: &ast::Expr,
body: &ast::Block)
- -> Block<'blk, 'tcx> {
+ -> Block<'blk, 'tcx>
+{
let _icx = push_ctxt("trans_for");
// bcx
.borrow())[method_call]
.ty;
let method_type = monomorphize_type(loopback_bcx_in, method_type);
- let method_result_type = ty::ty_fn_ret(method_type).unwrap();
+ let method_result_type =
+ ty::assert_no_late_bound_regions( // LB regions are instantiated in invoked methods
+ loopback_bcx_in.tcx(), &ty::ty_fn_ret(method_type)).unwrap();
let option_cleanup_scope = body_bcx_in.fcx.push_custom_cleanup_scope();
let option_cleanup_scope_id = cleanup::CustomScope(option_cleanup_scope);
match bcx.tcx().def_map.borrow().get(&expr_id) {
Some(&def::DefLabel(loop_id)) => loop_id,
ref r => {
- bcx.tcx().sess.bug(format!("{} in def-map for label",
- r)[])
+ bcx.tcx().sess.bug(format!("{:?} in def-map for label",
+ r).index(&FullRange))
}
}
}
let v_str = C_str_slice(ccx, fail_str);
let loc = bcx.sess().codemap().lookup_char_pos(sp.lo);
- let filename = token::intern_and_get_ident(loc.file.name[]);
+ let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange));
let filename = C_str_slice(ccx, filename);
let line = C_uint(ccx, loc.line);
let expr_file_line_const = C_struct(ccx, &[v_str, filename, line], false);
let did = langcall(bcx, Some(sp), "", PanicFnLangItem);
let bcx = callee::trans_lang_call(bcx,
did,
- args[],
+ args.index(&FullRange),
Some(expr::Ignore)).bcx;
Unreachable(bcx);
return bcx;
// Extract the file/line from the span
let loc = bcx.sess().codemap().lookup_char_pos(sp.lo);
- let filename = token::intern_and_get_ident(loc.file.name[]);
+ let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange));
// Invoke the lang item
let filename = C_str_slice(ccx, filename);
let did = langcall(bcx, Some(sp), "", PanicBoundsCheckFnLangItem);
let bcx = callee::trans_lang_call(bcx,
did,
- args[],
+ args.index(&FullRange),
Some(expr::Ignore)).bcx;
Unreachable(bcx);
return bcx;
}
_ => bcx.tcx().sess.bug(
format!("Unexpected unsized type in get_element: {}",
- bcx.ty_to_string(self.ty))[])
+ bcx.ty_to_string(self.ty)).index(&FullRange))
};
Datum {
val: val,
#[allow(dead_code)] // useful for debugging
pub fn to_string<'a>(&self, ccx: &CrateContext<'a, 'tcx>) -> String {
- format!("Datum({}, {}, {})",
+ format!("Datum({}, {}, {:?})",
ccx.tn().val_to_string(self.val),
ty_to_string(ccx.tcx(), self.ty),
self.kind)
metadata: DIType) {
if self.type_to_metadata.insert(type_, metadata).is_some() {
cx.sess().bug(format!("Type metadata for Ty '{}' is already in the TypeMap!",
- ppaux::ty_to_string(cx.tcx(), type_))[]);
+ ppaux::ty_to_string(cx.tcx(), type_)).index(&FullRange));
}
}
if self.unique_id_to_metadata.insert(unique_type_id, metadata).is_some() {
let unique_type_id_str = self.get_unique_type_id_as_string(unique_type_id);
cx.sess().bug(format!("Type metadata for unique id '{}' is already in the TypeMap!",
- unique_type_id_str[])[]);
+ unique_type_id_str.index(&FullRange)).index(&FullRange));
}
}
// unique ptr (~) -> {~ :pointee-uid:}
// @-ptr (@) -> {@ :pointee-uid:}
// sized vec ([T; x]) -> {[:size:] :element-uid:}
- // unsized vec ([T]) -> {[] :element-uid:}
+ // unsized vec ([T]) -> {.index(&FullRange) :element-uid:}
// trait (T) -> {trait_:svh: / :node-id:_<(:param-uid:),*> }
// closure -> {<unsafe_> <once_> :store-sigil: |(:param-uid:),* <,_...>| -> \
// :return-type-uid: : (:bounds:)*}
// function -> {<unsafe_> <abi_> fn( (:param-uid:)* <,_...> ) -> \
// :return-type-uid:}
- // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>}
+ // unique vec box (~.index(&FullRange)) -> {HEAP_VEC_BOX<:pointee-uid:>}
// gc box -> {GC_BOX<:pointee-uid:>}
match self.type_to_unique_id.get(&type_).cloned() {
self.get_unique_type_id_of_type(cx, component_type);
let component_type_id =
self.get_unique_type_id_as_string(component_type_id);
- unique_type_id.push_str(component_type_id[]);
+ unique_type_id.push_str(component_type_id.index(&FullRange));
}
},
ty::ty_uniq(inner_type) => {
unique_type_id.push('~');
let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
- unique_type_id.push_str(inner_type_id[]);
+ unique_type_id.push_str(inner_type_id.index(&FullRange));
},
ty::ty_ptr(ty::mt { ty: inner_type, mutbl } ) => {
unique_type_id.push('*');
let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
- unique_type_id.push_str(inner_type_id[]);
+ unique_type_id.push_str(inner_type_id.index(&FullRange));
},
ty::ty_rptr(_, ty::mt { ty: inner_type, mutbl }) => {
unique_type_id.push('&');
let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
- unique_type_id.push_str(inner_type_id[]);
+ unique_type_id.push_str(inner_type_id.index(&FullRange));
},
ty::ty_vec(inner_type, optional_length) => {
match optional_length {
Some(len) => {
- unique_type_id.push_str(format!("[{}]", len)[]);
+ unique_type_id.push_str(format!("[{}]", len).index(&FullRange));
}
None => {
unique_type_id.push_str("[]");
let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
- unique_type_id.push_str(inner_type_id[]);
+ unique_type_id.push_str(inner_type_id.index(&FullRange));
},
ty::ty_trait(ref trait_data) => {
unique_type_id.push_str("trait ");
+ let principal =
+ ty::erase_late_bound_regions(cx.tcx(),
+ &trait_data.principal);
+
from_def_id_and_substs(self,
cx,
- trait_data.principal_def_id(),
- trait_data.principal.0.substs,
+ principal.def_id,
+ principal.substs,
&mut unique_type_id);
},
ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => {
unique_type_id.push_str(" fn(");
- for ¶meter_type in sig.0.inputs.iter() {
+ let sig = ty::erase_late_bound_regions(cx.tcx(), sig);
+
+ for ¶meter_type in sig.inputs.iter() {
let parameter_type_id =
self.get_unique_type_id_of_type(cx, parameter_type);
let parameter_type_id =
self.get_unique_type_id_as_string(parameter_type_id);
- unique_type_id.push_str(parameter_type_id[]);
+ unique_type_id.push_str(parameter_type_id.index(&FullRange));
unique_type_id.push(',');
}
- if sig.0.variadic {
+ if sig.variadic {
unique_type_id.push_str("...");
}
unique_type_id.push_str(")->");
- match sig.0.output {
+ match sig.output {
ty::FnConverging(ret_ty) => {
let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty);
let return_type_id = self.get_unique_type_id_as_string(return_type_id);
- unique_type_id.push_str(return_type_id[]);
+ unique_type_id.push_str(return_type_id.index(&FullRange));
}
ty::FnDiverging => {
unique_type_id.push_str("!");
&mut unique_type_id);
},
_ => {
- cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {}",
- ppaux::ty_to_string(cx.tcx(), type_)[],
- type_.sty)[])
+ cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
+ ppaux::ty_to_string(cx.tcx(), type_).index(&FullRange),
+ type_.sty).index(&FullRange))
}
};
output.push_str(crate_hash.as_str());
output.push_str("/");
- output.push_str(format!("{:x}", def_id.node)[]);
+ output.push_str(format!("{:x}", def_id.node).index(&FullRange));
// Maybe check that there is no self type here.
type_map.get_unique_type_id_of_type(cx, type_parameter);
let param_type_id =
type_map.get_unique_type_id_as_string(param_type_id);
- output.push_str(param_type_id[]);
+ output.push_str(param_type_id.index(&FullRange));
output.push(',');
}
}
};
- for ¶meter_type in sig.0.inputs.iter() {
+ let sig = ty::erase_late_bound_regions(cx.tcx(), sig);
+
+ for ¶meter_type in sig.inputs.iter() {
let parameter_type_id =
self.get_unique_type_id_of_type(cx, parameter_type);
let parameter_type_id =
self.get_unique_type_id_as_string(parameter_type_id);
- unique_type_id.push_str(parameter_type_id[]);
+ unique_type_id.push_str(parameter_type_id.index(&FullRange));
unique_type_id.push(',');
}
- if sig.0.variadic {
+ if sig.variadic {
unique_type_id.push_str("...");
}
unique_type_id.push_str("|->");
- match sig.0.output {
+ match sig.output {
ty::FnConverging(ret_ty) => {
let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty);
let return_type_id = self.get_unique_type_id_as_string(return_type_id);
- unique_type_id.push_str(return_type_id[]);
+ unique_type_id.push_str(return_type_id.index(&FullRange));
}
ty::FnDiverging => {
unique_type_id.push_str("!");
let enum_type_id = self.get_unique_type_id_of_type(cx, enum_type);
let enum_variant_type_id = format!("{}::{}",
self.get_unique_type_id_as_string(enum_type_id)
- [],
+ .index(&FullRange),
variant_name);
let interner_key = self.unique_id_interner.intern(Rc::new(enum_variant_type_id));
UniqueTypeId(interner_key)
format!("debuginfo::\
create_global_var_metadata() -
Captured var-id refers to \
- unexpected ast_item variant: {}",
- var_item)[])
+ unexpected ast_item variant: {:?}",
+ var_item).index(&FullRange))
}
}
},
_ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() \
- Captured var-id refers to unexpected \
- ast_map variant: {}",
- var_item)[])
+ ast_map variant: {:?}",
+ var_item).index(&FullRange))
};
let (file_metadata, line_number) = if span != codemap::DUMMY_SP {
let loc = span_start(cx, span);
- (file_metadata(cx, loc.file.name[]), loc.line as c_uint)
+ (file_metadata(cx, loc.file.name.index(&FullRange)), loc.line as c_uint)
} else {
(UNKNOWN_FILE_METADATA, UNKNOWN_LINE_NUMBER)
};
let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id));
let var_name = token::get_ident(ident).get().to_string();
let linkage_name =
- namespace_node.mangled_name_of_contained_item(var_name[]);
+ namespace_node.mangled_name_of_contained_item(var_name.index(&FullRange));
let var_scope = namespace_node.scope;
let var_name = CString::from_slice(var_name.as_bytes());
None => {
bcx.sess().span_bug(span,
format!("no entry in lllocals table for {}",
- node_id)[]);
+ node_id).index(&FullRange));
}
};
format!(
"debuginfo::create_captured_var_metadata() - \
Captured var-id refers to unexpected \
- ast_map variant: {}",
- ast_item)[]);
+ ast_map variant: {:?}",
+ ast_item).index(&FullRange));
}
}
}
.span_bug(span,
format!("debuginfo::create_captured_var_metadata() - \
Captured var-id refers to unexpected \
- ast_map variant: {}",
- ast_item)[]);
+ ast_map variant: {:?}",
+ ast_item).index(&FullRange));
}
};
let variable_access = IndirectVariable {
alloca: env_pointer,
- address_operations: address_operations[..address_op_count]
+ address_operations: address_operations.index(&(0..address_op_count))
};
declare_local(bcx,
None => {
bcx.sess().span_bug(span,
format!("no entry in lllocals table for {}",
- node_id)[]);
+ node_id).index(&FullRange));
}
};
if let Some(code_snippet) = code_snippet {
let bytes = code_snippet.as_bytes();
- if bytes.len() > 0 && bytes[bytes.len()-1 ..] == b"}" {
+ if bytes.len() > 0 && bytes.index(&((bytes.len()-1)..)) == b"}" {
cleanup_span = Span {
lo: node_span.hi - codemap::BytePos(1),
hi: node_span.hi,
match expr.node {
ast::ExprClosure(_, _, ref fn_decl, ref top_level_block) => {
let name = format!("fn{}", token::gensym("fn"));
- let name = token::str_to_ident(name[]);
+ let name = token::str_to_ident(name.index(&FullRange));
(name, &**fn_decl,
// This is not quite right. It should actually inherit
// the generics of the enclosing function.
_ => {
cx.sess()
.bug(format!("create_function_debug_context: \
- unexpected sort of node: {}",
- fnitem)[])
+ unexpected sort of node: {:?}",
+ fnitem).index(&FullRange))
}
}
}
return FunctionDebugContext::FunctionWithoutDebugInfo;
}
_ => cx.sess().bug(format!("create_function_debug_context: \
- unexpected sort of node: {}",
- fnitem)[])
+ unexpected sort of node: {:?}",
+ fnitem).index(&FullRange))
};
// This can be the case for functions inlined from another crate
}
let loc = span_start(cx, span);
- let file_metadata = file_metadata(cx, loc.file.name[]);
+ let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
let function_type_metadata = unsafe {
let fn_signature = get_function_signature(cx,
let (linkage_name, containing_scope) = if has_path {
let namespace_node = namespace_for_item(cx, ast_util::local_def(fn_ast_id));
let linkage_name = namespace_node.mangled_name_of_contained_item(
- function_name[]);
+ function_name.index(&FullRange));
let containing_scope = namespace_node.scope;
(linkage_name, containing_scope)
} else {
signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP));
}
- return create_DIArray(DIB(cx), signature[]);
+ return create_DIArray(DIB(cx), signature.index(&FullRange));
}
fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
actual_self_type,
true);
- name_to_append_suffix_to.push_str(actual_self_type_name[]);
+ name_to_append_suffix_to.push_str(actual_self_type_name.index(&FullRange));
if generics.is_type_parameterized() {
name_to_append_suffix_to.push_str(",");
let actual_type_name = compute_debuginfo_type_name(cx,
actual_type,
true);
- name_to_append_suffix_to.push_str(actual_type_name[]);
+ name_to_append_suffix_to.push_str(actual_type_name.index(&FullRange));
if index != generics.ty_params.len() - 1 {
name_to_append_suffix_to.push_str(",");
name_to_append_suffix_to.push('>');
- return create_DIArray(DIB(cx), template_params[]);
+ return create_DIArray(DIB(cx), template_params.index(&FullRange));
}
}
}
};
- debug!("compile_unit_metadata: {}", compile_unit_name);
+ debug!("compile_unit_metadata: {:?}", compile_unit_name);
let producer = format!("rustc version {}",
(option_env!("CFG_VERSION")).expect("CFG_VERSION"));
let cx: &CrateContext = bcx.ccx();
let filename = span_start(cx, span).file.name.clone();
- let file_metadata = file_metadata(cx, filename[]);
+ let file_metadata = file_metadata(cx, filename.index(&FullRange));
let name = token::get_ident(variable_ident);
let loc = span_start(cx, span);
let work_dir = cx.sess().working_dir.as_str().unwrap();
let file_name =
if full_path.starts_with(work_dir) {
- full_path[work_dir.len() + 1u..full_path.len()]
+ full_path.index(&((work_dir.len() + 1u)..full_path.len()))
} else {
full_path
};
let node = fcx.ccx.tcx().map.get(node_id);
fcx.ccx.sess().span_bug(error_reporting_span,
- format!("debuginfo: Could not find scope info for node {}",
- node)[]);
+ format!("debuginfo: Could not find scope info for node {:?}",
+ node).index(&FullRange));
}
}
}
fn basic_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
t: Ty<'tcx>) -> DIType {
- debug!("basic_type_metadata: {}", t);
+ debug!("basic_type_metadata: {:?}", t);
let (name, encoding) = match t.sty {
ty::ty_tup(ref elements) if elements.is_empty() =>
ty::ty_bool => ("bool".to_string(), DW_ATE_boolean),
ty::ty_char => ("char".to_string(), DW_ATE_unsigned_char),
ty::ty_int(int_ty) => match int_ty {
- ast::TyI => ("int".to_string(), DW_ATE_signed),
+ ast::TyIs => ("isize".to_string(), DW_ATE_signed),
ast::TyI8 => ("i8".to_string(), DW_ATE_signed),
ast::TyI16 => ("i16".to_string(), DW_ATE_signed),
ast::TyI32 => ("i32".to_string(), DW_ATE_signed),
ast::TyI64 => ("i64".to_string(), DW_ATE_signed)
},
ty::ty_uint(uint_ty) => match uint_ty {
- ast::TyU => ("uint".to_string(), DW_ATE_unsigned),
+ ast::TyUs => ("usize".to_string(), DW_ATE_unsigned),
ast::TyU8 => ("u8".to_string(), DW_ATE_unsigned),
ast::TyU16 => ("u16".to_string(), DW_ATE_unsigned),
ast::TyU32 => ("u32".to_string(), DW_ATE_unsigned),
cx.sess().bug(format!("Forward declaration of potentially recursive type \
'{}' was not found in TypeMap!",
ppaux::ty_to_string(cx.tcx(), unfinished_type))
- []);
+ .index(&FullRange));
}
}
set_members_of_composite_type(cx,
metadata_stub,
llvm_type,
- member_descriptions[]);
+ member_descriptions.index(&FullRange));
return MetadataCreationResult::new(metadata_stub, true);
}
}
let struct_metadata_stub = create_struct_stub(cx,
struct_llvm_type,
- struct_name[],
+ struct_name.index(&FullRange),
unique_type_id,
containing_scope);
unique_type_id,
create_struct_stub(cx,
tuple_llvm_type,
- tuple_name[],
+ tuple_name.index(&FullRange),
unique_type_id,
UNKNOWN_SCOPE_METADATA),
tuple_llvm_type,
set_members_of_composite_type(cx,
variant_type_metadata,
variant_llvm_type,
- member_descriptions[]);
+ member_descriptions.index(&FullRange));
MemberDescription {
name: "".to_string(),
llvm_type: variant_llvm_type,
set_members_of_composite_type(cx,
variant_type_metadata,
variant_llvm_type,
- member_descriptions[]);
+ member_descriptions.index(&FullRange));
vec![
MemberDescription {
name: "".to_string(),
set_members_of_composite_type(cx,
variant_type_metadata,
variant_llvm_type,
- variant_member_descriptions[]);
+ variant_member_descriptions.index(&FullRange));
// Encode the information about the null variant in the union
// member's name.
.iter()
.map(|&t| type_of::type_of(cx, t))
.collect::<Vec<_>>()
- [],
+ .index(&FullRange),
struct_def.packed);
// Could do some consistency checks here: size, align, field count, discr type
let (containing_scope, definition_span) = get_namespace_and_span_for_item(cx, enum_def_id);
let loc = span_start(cx, definition_span);
- let file_metadata = file_metadata(cx, loc.file.name[]);
+ let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
let variants = ty::enum_variants(cx.tcx(), enum_def_id);
Please use a rustc built with anewer \
version of LLVM.",
llvm_version_major,
- llvm_version_minor)[]);
+ llvm_version_minor).index(&FullRange));
} else {
cx.sess().bug("debuginfo::set_members_of_composite_type() - \
Already completed forward declaration re-encountered.");
.collect();
unsafe {
- let type_array = create_DIArray(DIB(cx), member_metadata[]);
+ let type_array = create_DIArray(DIB(cx), member_metadata.index(&FullRange));
llvm::LLVMDICompositeTypeSetTypeArray(composite_type_metadata, type_array);
}
}
let member_llvm_types = slice_llvm_type.field_types();
assert!(slice_layout_is_correct(cx,
- member_llvm_types[],
+ member_llvm_types.index(&FullRange),
element_type));
let member_descriptions = [
MemberDescription {
assert!(member_descriptions.len() == member_llvm_types.len());
let loc = span_start(cx, span);
- let file_metadata = file_metadata(cx, loc.file.name[]);
+ let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
let metadata = composite_type_metadata(cx,
slice_llvm_type,
- slice_type_name[],
+ slice_type_name.index(&FullRange),
unique_type_id,
&member_descriptions,
UNKNOWN_SCOPE_METADATA,
unique_type_id: UniqueTypeId,
signature: &ty::PolyFnSig<'tcx>,
span: Span)
- -> MetadataCreationResult {
- let mut signature_metadata: Vec<DIType> = Vec::with_capacity(signature.0.inputs.len() + 1);
+ -> MetadataCreationResult
+{
+ let signature = ty::erase_late_bound_regions(cx.tcx(), signature);
+
+ let mut signature_metadata: Vec<DIType> = Vec::with_capacity(signature.inputs.len() + 1);
// return type
- signature_metadata.push(match signature.0.output {
+ signature_metadata.push(match signature.output {
ty::FnConverging(ret_ty) => match ret_ty.sty {
ty::ty_tup(ref tys) if tys.is_empty() => ptr::null_mut(),
_ => type_metadata(cx, ret_ty, span)
});
// regular arguments
- for &argument_type in signature.0.inputs.iter() {
+ for &argument_type in signature.inputs.iter() {
signature_metadata.push(type_metadata(cx, argument_type, span));
}
llvm::LLVMDIBuilderCreateSubroutineType(
DIB(cx),
UNKNOWN_FILE_METADATA,
- create_DIArray(DIB(cx), signature_metadata[]))
+ create_DIArray(DIB(cx), signature_metadata.index(&FullRange)))
},
false);
}
let pp_type_name = ppaux::ty_to_string(cx.tcx(), trait_type);
cx.sess().bug(format!("debuginfo: Unexpected trait-object type in \
trait_pointer_metadata(): {}",
- pp_type_name[])[]);
+ pp_type_name.index(&FullRange)).index(&FullRange));
}
};
composite_type_metadata(cx,
trait_llvm_type,
- trait_type_name[],
+ trait_type_name.index(&FullRange),
unique_type_id,
&[],
containing_scope,
}
};
- debug!("type_metadata: {}", t);
+ debug!("type_metadata: {:?}", t);
let sty = &t.sty;
let MetadataCreationResult { metadata, already_stored_in_typemap } = match *sty {
ty::ty_tup(ref elements) => {
prepare_tuple_metadata(cx,
t,
- elements[],
+ elements.index(&FullRange),
unique_type_id,
usage_site_span).finalize(cx)
}
_ => {
- cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {}",
- sty)[])
+ cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {:?}",
+ sty).index(&FullRange))
}
};
type id '{}' to already be in \
the debuginfo::TypeMap but it \
was not. (Ty = {})",
- unique_type_id_str[],
+ unique_type_id_str.index(&FullRange),
ppaux::ty_to_string(cx.tcx(), t));
- cx.sess().span_bug(usage_site_span, error_message[]);
+ cx.sess().span_bug(usage_site_span, error_message.index(&FullRange));
}
};
UniqueTypeId maps in \
debuginfo::TypeMap. \
UniqueTypeId={}, Ty={}",
- unique_type_id_str[],
+ unique_type_id_str.index(&FullRange),
ppaux::ty_to_string(cx.tcx(), t));
- cx.sess().span_bug(usage_site_span, error_message[]);
+ cx.sess().span_bug(usage_site_span, error_message.index(&FullRange));
}
}
None => {
{
// Create a new lexical scope and push it onto the stack
let loc = cx.sess().codemap().lookup_char_pos(scope_span.lo);
- let file_metadata = file_metadata(cx, loc.file.name[]);
+ let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
let parent_scope = scope_stack.last().unwrap().scope_metadata;
let scope_metadata = unsafe {
if need_new_scope {
// Create a new lexical scope and push it onto the stack
let loc = cx.sess().codemap().lookup_char_pos(pat.span.lo);
- let file_metadata = file_metadata(cx, loc.file.name[]);
+ let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
let parent_scope = scope_stack.last().unwrap().scope_metadata;
let scope_metadata = unsafe {
ty::ty_bool => output.push_str("bool"),
ty::ty_char => output.push_str("char"),
ty::ty_str => output.push_str("str"),
- ty::ty_int(ast::TyI) => output.push_str("int"),
+ ty::ty_int(ast::TyIs) => output.push_str("isize"),
ty::ty_int(ast::TyI8) => output.push_str("i8"),
ty::ty_int(ast::TyI16) => output.push_str("i16"),
ty::ty_int(ast::TyI32) => output.push_str("i32"),
ty::ty_int(ast::TyI64) => output.push_str("i64"),
- ty::ty_uint(ast::TyU) => output.push_str("uint"),
+ ty::ty_uint(ast::TyUs) => output.push_str("usize"),
ty::ty_uint(ast::TyU8) => output.push_str("u8"),
ty::ty_uint(ast::TyU16) => output.push_str("u16"),
ty::ty_uint(ast::TyU32) => output.push_str("u32"),
output.push(']');
},
ty::ty_trait(ref trait_data) => {
- push_item_name(cx, trait_data.principal_def_id(), false, output);
- push_type_params(cx, trait_data.principal.0.substs, output);
+ let principal = ty::erase_late_bound_regions(cx.tcx(), &trait_data.principal);
+ push_item_name(cx, principal.def_id, false, output);
+ push_type_params(cx, principal.substs, output);
},
ty::ty_bare_fn(_, &ty::BareFnTy{ unsafety, abi, ref sig } ) => {
if unsafety == ast::Unsafety::Unsafe {
output.push_str("fn(");
- if sig.0.inputs.len() > 0 {
- for ¶meter_type in sig.0.inputs.iter() {
+ let sig = ty::erase_late_bound_regions(cx.tcx(), sig);
+ if sig.inputs.len() > 0 {
+ for ¶meter_type in sig.inputs.iter() {
push_debuginfo_type_name(cx, parameter_type, true, output);
output.push_str(", ");
}
output.pop();
}
- if sig.0.variadic {
- if sig.0.inputs.len() > 0 {
+ if sig.variadic {
+ if sig.inputs.len() > 0 {
output.push_str(", ...");
} else {
output.push_str("...");
output.push(')');
- match sig.0.output {
+ match sig.output {
ty::FnConverging(result_type) if ty::type_is_nil(result_type) => {}
ty::FnConverging(result_type) => {
output.push_str(" -> ");
ty::ty_projection(..) |
ty::ty_param(_) => {
cx.sess().bug(format!("debuginfo: Trying to create type name for \
- unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t))[]);
+ unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange));
}
}
None => {}
}
let string = token::get_name(node.name);
- output.push_str(format!("{}", string.get().len())[]);
+ output.push_str(format!("{}", string.get().len()).index(&FullRange));
output.push_str(string.get());
}
let mut name = String::from_str("_ZN");
fill_nested(self, &mut name);
- name.push_str(format!("{}", item_name.len())[]);
+ name.push_str(format!("{}", item_name.len()).index(&FullRange));
name.push_str(item_name);
name.push('E');
name
}
fn crate_root_namespace<'a>(cx: &'a CrateContext) -> &'a str {
- cx.link_meta().crate_name[]
+ cx.link_meta().crate_name.index(&FullRange)
}
fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTreeNode> {
Some(node) => node,
None => {
cx.sess().bug(format!("debuginfo::namespace_for_item(): \
- path too short for {}",
- def_id)[]);
+ path too short for {:?}",
+ def_id).index(&FullRange));
}
}
})
// FIXME(#19596) workaround: `|t| t` causes monomorphization recursion
fn identity<T>(t: T) -> T { t }
- debug!("unsized_info(kind={}, id={}, unadjusted_ty={})",
+ debug!("unsized_info(kind={:?}, id={}, unadjusted_ty={})",
kind, id, unadjusted_ty.repr(bcx.tcx()));
match kind {
&ty::UnsizeLength(len) => C_uint(bcx.ccx(), len),
unsized_info(bcx, k, id, ty_substs[tp_index], identity)
}
_ => bcx.sess().bug(format!("UnsizeStruct with bad sty: {}",
- bcx.ty_to_string(unadjusted_ty))[])
+ bcx.ty_to_string(unadjusted_ty)).index(&FullRange))
},
&ty::UnsizeVtable(ty::TyTrait { ref principal, .. }, _) => {
// Note that we preserve binding levels here:
let unboxed_ty = match datum_ty.sty {
ty::ty_uniq(t) => t,
_ => bcx.sess().bug(format!("Expected ty_uniq, found {}",
- bcx.ty_to_string(datum_ty))[])
+ bcx.ty_to_string(datum_ty)).index(&FullRange))
};
let result_ty = ty::mk_uniq(tcx, ty::unsize_ty(tcx, unboxed_ty, k, expr.span));
trans_rec_tup_field(bcx, &**base, idx.node)
}
ast::ExprIndex(ref base, ref idx) => {
- match idx.node {
- ast::ExprRange(ref start, ref end) => {
- // Special case for slicing syntax (KILLME).
- let _icx = push_ctxt("trans_slice");
- let ccx = bcx.ccx();
-
- let method_call = MethodCall::expr(expr.id);
- let method_ty = ccx.tcx()
- .method_map
- .borrow()
- .get(&method_call)
- .map(|method| method.ty);
- let base_datum = unpack_datum!(bcx, trans(bcx, &**base));
-
- let mut args = vec![];
- start.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id)));
- end.as_ref().map(|e| args.push((unpack_datum!(bcx, trans(bcx, &**e)), e.id)));
-
- let result_ty = ty::ty_fn_ret(monomorphize_type(bcx,
- method_ty.unwrap())).unwrap();
- let scratch = rvalue_scratch_datum(bcx, result_ty, "trans_slice");
-
- unpack_result!(bcx,
- trans_overloaded_op(bcx,
- expr,
- method_call,
- base_datum,
- args,
- Some(SaveIn(scratch.val)),
- true));
- DatumBlock::new(bcx, scratch.to_expr_datum())
- }
- _ => trans_index(bcx, expr, &**base, &**idx, MethodCall::expr(expr.id))
- }
+ trans_index(bcx, expr, &**base, &**idx, MethodCall::expr(expr.id))
}
ast::ExprBox(_, ref contents) => {
// Special case for `Box<T>`
bcx.tcx().sess.span_bug(
expr.span,
format!("trans_rvalue_datum_unadjusted reached \
- fall-through case: {}",
- expr.node)[]);
+ fall-through case: {:?}",
+ expr.node).index(&FullRange));
}
}
}
.map(|method| method.ty);
let elt_datum = match method_ty {
Some(method_ty) => {
+ let method_ty = monomorphize_type(bcx, method_ty);
+
let base_datum = unpack_datum!(bcx, trans(bcx, base));
// Translate index expression.
let ix_datum = unpack_datum!(bcx, trans(bcx, idx));
- let ref_ty = ty::ty_fn_ret(monomorphize_type(bcx, method_ty)).unwrap();
+ let ref_ty = // invoked methods have LB regions instantiated:
+ ty::assert_no_late_bound_regions(
+ bcx.tcx(), &ty::ty_fn_ret(method_ty)).unwrap();
let elt_ty = match ty::deref(ref_ty, true) {
None => {
bcx.tcx().sess.span_bug(index_expr.span,
bcx.tcx().sess.span_bug(
expr.span,
format!("trans_rvalue_stmt_unadjusted reached \
- fall-through case: {}",
- expr.node)[]);
+ fall-through case: {:?}",
+ expr.node).index(&FullRange));
}
}
}
controlflow::trans_if(bcx, expr.id, &**cond, &**thn, els.as_ref().map(|e| &**e), dest)
}
ast::ExprMatch(ref discr, ref arms, _) => {
- _match::trans_match(bcx, expr, &**discr, arms[], dest)
+ _match::trans_match(bcx, expr, &**discr, arms.index(&FullRange), dest)
}
ast::ExprBlock(ref blk) => {
controlflow::trans_block(bcx, &**blk, dest)
}
ast::ExprStruct(_, ref fields, ref base) => {
trans_struct(bcx,
- fields[],
+ fields.index(&FullRange),
base.as_ref().map(|e| &**e),
expr.span,
expr.id,
trans_adt(bcx,
expr_ty(bcx, expr),
0,
- numbered_fields[],
+ numbered_fields.index(&FullRange),
None,
dest,
Some(NodeInfo { id: expr.id, span: expr.span }))
trans_overloaded_call(bcx,
expr,
&**f,
- args[],
+ args.index(&FullRange),
Some(dest))
} else {
callee::trans_call(bcx,
expr,
&**f,
- callee::ArgExprs(args[]),
+ callee::ArgExprs(args.index(&FullRange)),
dest)
}
}
callee::trans_method_call(bcx,
expr,
&*args[0],
- callee::ArgExprs(args[]),
+ callee::ArgExprs(args.index(&FullRange)),
dest)
}
ast::ExprBinary(op, ref lhs, ref rhs) => {
bcx.tcx().sess.span_bug(
expr.span,
format!("trans_rvalue_dps_unadjusted reached fall-through \
- case: {}",
- expr.node)[]);
+ case: {:?}",
+ expr.node).index(&FullRange));
}
}
}
}
_ => {
bcx.tcx().sess.span_bug(ref_expr.span, format!(
- "Non-DPS def {} referened by {}",
- def, bcx.node_id_to_string(ref_expr.id))[]);
+ "Non-DPS def {:?} referened by {}",
+ def, bcx.node_id_to_string(ref_expr.id)).index(&FullRange));
}
}
}
}
_ => {
ccx.tcx().sess.span_bug(ref_expr.span, format!(
- "trans_def_fn_unadjusted invoked on: {} for {}",
+ "trans_def_fn_unadjusted invoked on: {:?} for {}",
def,
- ref_expr.repr(ccx.tcx()))[]);
+ ref_expr.repr(ccx.tcx())).index(&FullRange));
}
}
}
None => {
bcx.sess().bug(format!(
"trans_local_var: no llval for upvar {} found",
- nid)[]);
+ nid).index(&FullRange));
}
}
}
None => {
bcx.sess().bug(format!(
"trans_local_var: no datum for local/arg {} found",
- nid)[]);
+ nid).index(&FullRange));
}
};
debug!("take_local(nid={}, v={}, ty={})",
}
_ => {
bcx.sess().unimpl(format!(
- "unsupported def type in trans_local_var: {}",
- def)[]);
+ "unsupported def type in trans_local_var: {:?}",
+ def).index(&FullRange));
}
}
}
{
match ty.sty {
ty::ty_struct(did, substs) => {
- op(0, struct_fields(tcx, did, substs)[])
+ op(0, struct_fields(tcx, did, substs).index(&FullRange))
}
ty::ty_tup(ref v) => {
- op(0, tup_fields(v[])[])
+ op(0, tup_fields(v.index(&FullRange)).index(&FullRange))
}
ty::ty_enum(_, substs) => {
tcx.sess.bug(format!(
"cannot get field types from the enum type {} \
without a node ID",
- ty.repr(tcx))[]);
+ ty.repr(tcx)).index(&FullRange));
}
Some(node_id) => {
let def = tcx.def_map.borrow()[node_id].clone();
op(variant_info.disr_val,
struct_fields(tcx,
variant_id,
- substs)[])
+ substs).index(&FullRange))
}
_ => {
tcx.sess.bug("resolve didn't map this expr to a \
_ => {
tcx.sess.bug(format!(
"cannot get field types from the type {}",
- ty.repr(tcx))[]);
+ ty.repr(tcx)).index(&FullRange));
}
}
}
let tcx = bcx.tcx();
with_field_tys(tcx, ty, Some(expr_id), |discr, field_tys| {
- let mut need_base: Vec<_> = repeat(true).take(field_tys.len()).collect();
+ let mut need_base: Vec<bool> = repeat(true).take(field_tys.len()).collect();
let numbered_fields = fields.iter().map(|field| {
let opt_pos =
field_tys.iter().position(|field_ty|
field_ty.name == field.ident.node.name);
- match opt_pos {
+ let result = match opt_pos {
Some(i) => {
need_base[i] = false;
(i, &*field.expr)
tcx.sess.span_bug(field.span,
"Couldn't find field in struct type")
}
- }
+ };
+ result
}).collect::<Vec<_>>();
let optbase = match base {
Some(base_expr) => {
let mut leftovers = Vec::new();
for (i, b) in need_base.iter().enumerate() {
if *b {
- leftovers.push((i, field_tys[i].mt.ty))
+ leftovers.push((i, field_tys[i].mt.ty));
}
}
Some(StructBaseInfo {expr: base_expr,
trans_adt(bcx,
ty,
discr,
- numbered_fields[],
+ numbered_fields.as_slice(),
optbase,
dest,
Some(NodeInfo { id: expr_id, span: expr_span }))
cast_float => SIToFP(bcx, lldiscrim_a, ll_t_out),
_ => {
ccx.sess().bug(format!("translating unsupported cast: \
- {} ({}) -> {} ({})",
+ {} ({:?}) -> {} ({:?})",
t_in.repr(bcx.tcx()),
k_in,
t_out.repr(bcx.tcx()),
- k_out)[])
+ k_out).index(&FullRange))
}
}
}
_ => ccx.sess().bug(format!("translating unsupported cast: \
- {} ({}) -> {} ({})",
+ {} ({:?}) -> {} ({:?})",
t_in.repr(bcx.tcx()),
k_in,
t_out.repr(bcx.tcx()),
- k_out)[])
+ k_out).index(&FullRange))
};
return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock();
}
-> DatumBlock<'blk, 'tcx, Expr> {
let ccx = bcx.ccx();
- debug!("deref_once(expr={}, datum={}, method_call={})",
+ debug!("deref_once(expr={}, datum={}, method_call={:?})",
expr.repr(bcx.tcx()),
datum.to_string(ccx),
method_call);
.get(&method_call).map(|method| method.ty);
let datum = match method_ty {
Some(method_ty) => {
+ let method_ty = monomorphize_type(bcx, method_ty);
+
// Overloaded. Evaluate `trans_overloaded_op`, which will
// invoke the user's deref() method, which basically
// converts from the `Smaht<T>` pointer that we have into
_ => datum
};
- let ref_ty = ty::ty_fn_ret(monomorphize_type(bcx, method_ty)).unwrap();
+ let ref_ty = // invoked methods have their LB regions instantiated
+ ty::assert_no_late_bound_regions(
+ ccx.tcx(), &ty::ty_fn_ret(method_ty)).unwrap();
let scratch = rvalue_scratch_datum(bcx, ref_ty, "overloaded_deref");
unpack_result!(bcx, trans_overloaded_op(bcx, expr, method_call,
bcx.tcx().sess.span_bug(
expr.span,
format!("deref invoked on expr of illegal type {}",
- datum.ty.repr(bcx.tcx()))[]);
+ datum.ty.repr(bcx.tcx())).index(&FullRange));
}
};
- debug!("deref_once(expr={}, method_call={}, result={})",
+ debug!("deref_once(expr={}, method_call={:?}, result={})",
expr.id, method_call, r.datum.to_string(ccx));
return r;
struct ForeignTypes<'tcx> {
/// Rust signature of the function
- fn_sig: ty::PolyFnSig<'tcx>,
+ fn_sig: ty::FnSig<'tcx>,
/// Adapter object for handling native ABI rules (trust me, you
/// don't want to know)
let llty = type_of::type_of(ccx, ty);
let ident = link_name(foreign_item);
- match attr::first_attr_value_str_by_name(foreign_item.attrs[],
+ match attr::first_attr_value_str_by_name(foreign_item.attrs.index(&FullRange),
"linkage") {
// If this is a static with a linkage specified, then we need to handle
// it a little specially. The typesystem prevents things like &T and
// Make sure the calling convention is right for variadic functions
// (should've been caught if not in typeck)
- if tys.fn_sig.0.variadic {
+ if tys.fn_sig.variadic {
assert!(cc == llvm::CCallConv);
}
llretptr: ValueRef,
llargs_rust: &[ValueRef],
passed_arg_tys: Vec<Ty<'tcx>>)
- -> Block<'blk, 'tcx> {
+ -> Block<'blk, 'tcx>
+{
let ccx = bcx.ccx();
let tcx = bcx.tcx();
ccx.tn().val_to_string(llretptr));
let (fn_abi, fn_sig) = match callee_ty.sty {
- ty::ty_bare_fn(_, ref fn_ty) => (fn_ty.abi, fn_ty.sig.clone()),
+ ty::ty_bare_fn(_, ref fn_ty) => (fn_ty.abi, &fn_ty.sig),
_ => ccx.sess().bug("trans_native_call called on non-function type")
};
- let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys[]);
+ let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig);
+ let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys.index(&FullRange));
let fn_type = cabi::compute_abi_info(ccx,
- llsig.llarg_tys[],
+ llsig.llarg_tys.index(&FullRange),
llsig.llret_ty,
llsig.ret_def);
- let arg_tys: &[cabi::ArgType] = fn_type.arg_tys[];
+ let arg_tys: &[cabi::ArgType] = fn_type.arg_tys.index(&FullRange);
let mut llargs_foreign = Vec::new();
let llforeign_retval = CallWithConv(bcx,
llfn,
- llargs_foreign[],
+ llargs_foreign.index(&FullRange),
cc,
Some(attrs));
debug!("llforeign_ret_ty={}", ccx.tn().type_to_string(llforeign_ret_ty));
if llrust_ret_ty == llforeign_ret_ty {
- match fn_sig.0.output {
+ match fn_sig.output {
ty::FnConverging(result_ty) => {
base::store_ty(bcx, llforeign_retval, llretptr, result_ty)
}
abi => {
let ty = ty::node_id_to_type(ccx.tcx(), foreign_item.id);
register_foreign_item_fn(ccx, abi, ty,
- lname.get()[]);
+ lname.get().index(&FullRange));
// Unlike for other items, we shouldn't call
// `base::update_linkage` here. Foreign items have
// special linkage requirements, which are handled
ccx.sess().bug(format!("build_rust_fn: extern fn {} has ty {}, \
expected a bare fn ty",
ccx.tcx().map.path_to_string(id),
- t.repr(tcx))[]);
+ t.repr(tcx)).index(&FullRange));
}
};
ccx.tcx().map.path_to_string(id),
id, t.repr(tcx));
- let llfn = base::decl_internal_rust_fn(ccx, t, ps[]);
+ let llfn = base::decl_internal_rust_fn(ccx, t, ps.index(&FullRange));
base::set_llvm_fn_attrs(ccx, attrs, llfn);
base::trans_fn(ccx, decl, body, llfn, param_substs, id, &[]);
llfn
};
// Push Rust return pointer, using null if it will be unused.
- let rust_uses_outptr = match tys.fn_sig.0.output {
+ let rust_uses_outptr = match tys.fn_sig.output {
ty::FnConverging(ret_ty) => type_of::return_uses_outptr(ccx, ret_ty),
ty::FnDiverging => false
};
return_ty={}",
ccx.tn().val_to_string(slot),
ccx.tn().type_to_string(llrust_ret_ty),
- tys.fn_sig.0.output.repr(tcx));
+ tys.fn_sig.output.repr(tcx));
llrust_args.push(slot);
return_alloca = Some(slot);
}
// Build up the arguments to the call to the rust function.
// Careful to adapt for cases where the native convention uses
// a pointer and Rust does not or vice versa.
- for i in range(0, tys.fn_sig.0.inputs.len()) {
- let rust_ty = tys.fn_sig.0.inputs[i];
+ for i in range(0, tys.fn_sig.inputs.len()) {
+ let rust_ty = tys.fn_sig.inputs[i];
let llrust_ty = tys.llsig.llarg_tys[i];
let rust_indirect = type_of::arg_is_indirect(ccx, rust_ty);
let llforeign_arg_ty = tys.fn_ty.arg_tys[i];
debug!("calling llrustfn = {}, t = {}",
ccx.tn().val_to_string(llrustfn), t.repr(ccx.tcx()));
let attributes = base::get_fn_llvm_attributes(ccx, t);
- let llrust_ret_val = builder.call(llrustfn, llrust_args[], Some(attributes));
+ let llrust_ret_val = builder.call(llrustfn, llrust_args.as_slice(), Some(attributes));
// Get the return value where the foreign fn expects it.
let llforeign_ret_ty = match tys.fn_ty.ret_ty.cast {
// the massive simplifications that have occurred.
pub fn link_name(i: &ast::ForeignItem) -> InternedString {
- match attr::first_attr_value_str_by_name(i.attrs[], "link_name") {
+ match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), "link_name") {
Some(ln) => ln.clone(),
- None => match weak_lang_items::link_name(i.attrs[]) {
+ None => match weak_lang_items::link_name(i.attrs.index(&FullRange)) {
Some(name) => name,
None => token::get_ident(i.ident),
}
/// because foreign functions just plain ignore modes. They also don't pass aggregate values by
/// pointer like we do.
fn foreign_signature<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- fn_sig: &ty::PolyFnSig<'tcx>, arg_tys: &[Ty<'tcx>])
+ fn_sig: &ty::FnSig<'tcx>,
+ arg_tys: &[Ty<'tcx>])
-> LlvmSignature {
let llarg_tys = arg_tys.iter().map(|&arg| arg_type_of(ccx, arg)).collect();
- let (llret_ty, ret_def) = match fn_sig.0.output {
+ let (llret_ty, ret_def) = match fn_sig.output {
ty::FnConverging(ret_ty) =>
(type_of::arg_type_of(ccx, ret_ty), !return_type_is_void(ccx, ret_ty)),
ty::FnDiverging =>
fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
ty: Ty<'tcx>) -> ForeignTypes<'tcx> {
let fn_sig = match ty.sty {
- ty::ty_bare_fn(_, ref fn_ty) => fn_ty.sig.clone(),
+ ty::ty_bare_fn(_, ref fn_ty) => &fn_ty.sig,
_ => ccx.sess().bug("foreign_types_for_fn_ty called on non-function type")
};
- let llsig = foreign_signature(ccx, &fn_sig, fn_sig.0.inputs.as_slice());
+ let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig);
+ let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs.as_slice());
let fn_ty = cabi::compute_abi_info(ccx,
- llsig.llarg_tys[],
+ llsig.llarg_tys.index(&FullRange),
llsig.llret_ty,
llsig.ret_def);
debug!("foreign_types_for_fn_ty(\
fn_ty={} -> {}, \
ret_def={}",
ty.repr(ccx.tcx()),
- ccx.tn().types_to_str(llsig.llarg_tys[]),
+ ccx.tn().types_to_str(llsig.llarg_tys.index(&FullRange)),
ccx.tn().type_to_string(llsig.llret_ty),
- ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>()[]),
+ ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>().as_slice()),
ccx.tn().type_to_string(fn_ty.ret_ty.ty),
llsig.ret_def);
llargument_tys.push(llarg_ty);
}
- if tys.fn_sig.0.variadic {
+ if tys.fn_sig.variadic {
Type::variadic_func(llargument_tys.as_slice(), &llreturn_ty)
} else {
- Type::func(llargument_tys[], &llreturn_ty)
+ Type::func(llargument_tys.index(&FullRange), &llreturn_ty)
}
}
let (glue, new_sym) = match ccx.available_drop_glues().borrow().get(&t) {
Some(old_sym) => {
- let glue = decl_cdecl_fn(ccx, old_sym[], llfnty, ty::mk_nil(ccx.tcx()));
+ let glue = decl_cdecl_fn(ccx, old_sym.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx()));
(glue, None)
},
None => {
dtor_did: ast::DefId,
class_did: ast::DefId,
substs: &subst::Substs<'tcx>)
- -> Block<'blk, 'tcx> {
+ -> Block<'blk, 'tcx>
+{
let repr = adt::represent_type(bcx.ccx(), t);
// Find and call the actual destructor
let fty = ty::lookup_item_type(bcx.tcx(), dtor_did).ty.subst(bcx.tcx(), substs);
let self_ty = match fty.sty {
ty::ty_bare_fn(_, ref f) => {
- assert!(f.sig.0.inputs.len() == 1);
- f.sig.0.inputs[0]
+ let sig = ty::erase_late_bound_regions(bcx.tcx(), &f.sig);
+ assert!(sig.inputs.len() == 1);
+ sig.inputs[0]
}
_ => bcx.sess().bug(format!("Expected function type, found {}",
- bcx.ty_to_string(fty))[])
+ bcx.ty_to_string(fty)).index(&FullRange))
};
let (struct_data, info) = if type_is_sized(bcx.tcx(), t) {
class_did,
&[get_drop_glue_type(bcx.ccx(), t)],
ty::mk_nil(bcx.tcx()));
- let (_, variant_cx) = invoke(variant_cx, dtor_addr, args[], dtor_ty, None);
+ let (_, variant_cx) = invoke(variant_cx, dtor_addr, args.index(&FullRange), dtor_ty, None);
variant_cx.fcx.pop_and_trans_custom_cleanup_scope(variant_cx, field_scope);
variant_cx
(Mul(bcx, info, C_uint(bcx.ccx(), unit_size)), C_uint(bcx.ccx(), 8u))
}
_ => bcx.sess().bug(format!("Unexpected unsized type, found {}",
- bcx.ty_to_string(t))[])
+ bcx.ty_to_string(t)).index(&FullRange))
}
}
bcx.sess().warn(format!("Ignoring drop flag in destructor for {}\
because the struct is unsized. See issue\
#16758",
- bcx.ty_to_string(t))[]);
+ bcx.ty_to_string(t)).index(&FullRange));
trans_struct_drop(bcx, t, v0, dtor, did, substs)
}
}
note_unique_llvm_symbol(ccx, name);
let ty_name = token::intern_and_get_ident(
- ppaux::ty_to_string(ccx.tcx(), t)[]);
+ ppaux::ty_to_string(ccx.tcx(), t).index(&FullRange));
let ty_name = C_str_slice(ccx, ty_name);
debug!("--- declare_tydesc {}", ppaux::ty_to_string(ccx.tcx(), t));
let fn_nm = mangle_internal_name_by_type_and_seq(
ccx,
t,
- format!("glue_{}", name)[]);
- let llfn = decl_cdecl_fn(ccx, fn_nm[], llfnty, ty::mk_nil(ccx.tcx()));
+ format!("glue_{}", name).index(&FullRange));
+ let llfn = decl_cdecl_fn(ccx, fn_nm.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx()));
note_unique_llvm_symbol(ccx, fn_nm.clone());
return (fn_nm, llfn);
}
dest: expr::Dest,
substs: subst::Substs<'tcx>,
call_info: NodeInfo)
- -> Result<'blk, 'tcx> {
-
+ -> Result<'blk, 'tcx>
+{
let fcx = bcx.fcx;
let ccx = fcx.ccx;
let tcx = bcx.tcx();
let ret_ty = match callee_ty.sty {
- ty::ty_bare_fn(_, ref f) => f.sig.0.output,
+ ty::ty_bare_fn(_, ref f) => {
+ ty::erase_late_bound_regions(bcx.tcx(), &f.sig.output())
+ }
_ => panic!("expected bare_fn in trans_intrinsic_call")
};
let foreign_item = tcx.map.expect_foreign_item(node);
match *impl_item {
ast::MethodImplItem(ref method) => {
if method.pe_generics().ty_params.len() == 0u {
- let trans_everywhere = attr::requests_inline(method.attrs[]);
+ let trans_everywhere = attr::requests_inline(method.attrs.index(&FullRange));
for (ref ccx, is_origin) in ccx.maybe_iter(trans_everywhere) {
let llfn = get_item_val(ccx, method.id);
trans_fn(ccx,
}) => {
let trait_ref = ty::Binder(bcx.monomorphize(trait_ref));
let span = bcx.tcx().map.span(method_call.expr_id);
- debug!("method_call={} trait_ref={}",
+ debug!("method_call={:?} trait_ref={}",
method_call,
trait_ref.repr(bcx.tcx()));
let origin = fulfill_obligation(bcx.ccx(),
let _icx = push_ctxt("meth::trans_static_method_callee");
let tcx = ccx.tcx();
- debug!("trans_static_method_callee(method_id={}, trait_id={}, \
+ debug!("trans_static_method_callee(method_id={:?}, trait_id={}, \
expr_id={})",
method_id,
ty::item_path_str(tcx, trait_id),
} else {
csearch::get_item_path(tcx, method_id).last().unwrap().name()
};
- debug!("trans_static_method_callee: method_id={}, expr_id={}, \
+ debug!("trans_static_method_callee: method_id={:?}, expr_id={}, \
name={}", method_id, expr_id, token::get_name(mname));
// Find the substitutions for the fn itself. This includes
// Here, in this call, which I've written with explicit UFCS
// notation, the set of type parameters will be:
//
- // rcvr_type: [] <-- nothing declared on the trait itself
+ // rcvr_type: .index(&FullRange) <-- nothing declared on the trait itself
// rcvr_self: [Vec<int>] <-- the self type
// rcvr_method: [String] <-- method type parameter
//
//
// Recall that we matched `<Vec<int> as Convert>`. Trait
// resolution will have given us a substitution
- // containing `impl_substs=[[T=int],[],[]]` (the type
+ // containing `impl_substs=[[T=int],.index(&FullRange),.index(&FullRange)]` (the type
// parameters defined on the impl). We combine
// that with the `rcvr_method` from before, which tells us
// the type parameters from the *method*, to yield
- // `callee_substs=[[T=int],[],[U=String]]`.
+ // `callee_substs=[[T=int],.index(&FullRange),[U=String]]`.
let subst::SeparateVecsPerParamSpace {
types: impl_type,
selfs: impl_self,
}
_ => {
tcx.sess.bug(format!("static call to invalid vtable: {}",
- vtbl.repr(tcx))[]);
+ vtbl.repr(tcx)).index(&FullRange));
}
}
}
traits::VtableParam(..) => {
bcx.sess().bug(
format!("resolved vtable bad vtable {} in trans",
- vtable.repr(bcx.tcx()))[]);
+ vtable.repr(bcx.tcx())).index(&FullRange));
}
}
}
// Load the function from the vtable and cast it to the expected type.
debug!("(translating trait callee) loading method");
+
// Replace the self type (&Self or Box<Self>) with an opaque pointer.
let llcallee_ty = match callee_ty.sty {
ty::ty_bare_fn(_, ref f) if f.abi == Rust || f.abi == RustCall => {
+ let fake_sig =
+ ty::Binder(ty::FnSig {
+ inputs: f.sig.0.inputs.slice_from(1).to_vec(),
+ output: f.sig.0.output,
+ variadic: f.sig.0.variadic,
+ });
type_of_rust_fn(ccx,
Some(Type::i8p(ccx)),
- f.sig.0.inputs.slice_from(1),
- f.sig.0.output,
+ &fake_sig,
f.abi)
}
_ => {
// Upcast to the trait in question and extract out the substitutions.
let upcast_trait_ref = traits::upcast(ccx.tcx(), object_trait_ref.clone(), trait_id).unwrap();
- let object_substs = upcast_trait_ref.substs().clone().erase_regions();
+ let upcast_trait_ref = ty::erase_late_bound_regions(tcx, &upcast_trait_ref);
+ let object_substs = upcast_trait_ref.substs.clone().erase_regions();
debug!("trans_object_shim: object_substs={}", object_substs.repr(tcx));
// Lookup the type of this method as declared in the trait and apply substitutions.
let llfn =
decl_internal_rust_fn(ccx, method_bare_fn_ty, function_name.as_slice());
+ let sig = ty::erase_late_bound_regions(ccx.tcx(), &fty.sig);
+
//
let block_arena = TypedArena::new();
let empty_substs = Substs::trans_empty();
llfn,
ast::DUMMY_NODE_ID,
false,
- fty.sig.0.output,
+ sig.output,
&empty_substs,
None,
&block_arena);
- let mut bcx = init_function(&fcx, false, fty.sig.0.output);
+ let mut bcx = init_function(&fcx, false, sig.output);
// the first argument (`self`) will be a trait object
let llobject = get_param(fcx.llfn, fcx.arg_pos(0) as u32);
match fty.abi {
RustCall => {
// unpack the tuple to extract the input type arguments:
- match fty.sig.0.inputs[1].sty {
+ match sig.inputs[1].sty {
ty::ty_tup(ref tys) => tys.as_slice(),
_ => {
bcx.sess().bug(
format!("rust-call expects a tuple not {}",
- fty.sig.0.inputs[1].repr(tcx)).as_slice());
+ sig.inputs[1].repr(tcx)).as_slice());
}
}
}
_ => {
// skip the self parameter:
- fty.sig.0.inputs.slice_from(1)
+ sig.inputs.slice_from(1)
}
};
assert!(!fcx.needs_ret_allocas);
+ let sig =
+ ty::erase_late_bound_regions(bcx.tcx(), &fty.sig);
+
let dest =
fcx.llretslotptr.get().map(
- |_| expr::SaveIn(fcx.get_ret_slot(bcx, fty.sig.0.output, "ret_slot")));
+ |_| expr::SaveIn(fcx.get_ret_slot(bcx, sig.output, "ret_slot")));
let method_offset_in_vtable =
traits::get_vtable_index_of_object_method(bcx.tcx(),
ArgVals(llargs.as_slice()),
dest).bcx;
- finish_fn(&fcx, bcx, fty.sig.0.output);
+ finish_fn(&fcx, bcx, sig.output);
llfn
}
bcx.sess().bug(
format!("resolved vtable for {} to bad vtable {} in trans",
trait_ref.repr(bcx.tcx()),
- vtable.repr(bcx.tcx()))[]);
+ vtable.repr(bcx.tcx())).index(&FullRange));
}
}
});
let components: Vec<_> = head.into_iter().chain(ptrs).collect();
unsafe {
- let tbl = C_struct(ccx, components[], false);
+ let tbl = C_struct(ccx, components.index(&FullRange), false);
let sym = token::gensym("vtable");
let buf = CString::from_vec(format!("vtable{}", sym.uint()).into_bytes());
let vt_gvar = llvm::LLVMAddGlobal(ccx.llmod(), val_ty(tbl).to_ref(),
pub use self::context::CrateContext;
pub use self::common::gensym_name;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod macros;
mod doc;
debug!("monomorphic_fn(\
fn_id={}, \
real_substs={}, \
- ref_id={})",
+ ref_id={:?})",
fn_id.repr(ccx.tcx()),
psubsts.repr(ccx.tcx()),
ref_id);
debug!("monomorphic_fn(\
fn_id={}, \
psubsts={}, \
- hash_id={})",
+ hash_id={:?})",
fn_id.repr(ccx.tcx()),
psubsts.repr(ccx.tcx()),
hash_id);
ccx.sess(),
ccx.tcx().map.find(fn_id.node),
|| {
- format!("while monomorphizing {}, couldn't find it in \
+ format!("while monomorphizing {:?}, couldn't find it in \
the item map (may have attempted to monomorphize \
an item defined in a different crate?)",
fn_id)
hash = format!("h{}", state.result());
ccx.tcx().map.with_path(fn_id.node, |path| {
- exported_name(path, hash[])
+ exported_name(path, hash.index(&FullRange))
})
};
let mut hash_id = Some(hash_id);
let mut mk_lldecl = |&mut : abi: abi::Abi| {
let lldecl = if abi != abi::Rust {
- foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, s[])
+ foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, s.index(&FullRange))
} else {
- decl_internal_rust_fn(ccx, mono_ty, s[])
+ decl_internal_rust_fn(ccx, mono_ty, s.index(&FullRange))
};
ccx.monomorphized().borrow_mut().insert(hash_id.take().unwrap(), lldecl);
..
} => {
let d = mk_lldecl(abi);
- let needs_body = setup_lldecl(d, i.attrs[]);
+ let needs_body = setup_lldecl(d, i.attrs.index(&FullRange));
if needs_body {
if abi != abi::Rust {
foreign::trans_rust_fn_with_foreign_abi(
ccx, &**decl, &**body, &[], d, psubsts, fn_id.node,
- Some(hash[]));
+ Some(hash.index(&FullRange)));
} else {
trans_fn(ccx, &**decl, &**body, d, psubsts, fn_id.node, &[]);
}
trans_enum_variant(ccx,
parent,
&*v,
- args[],
+ args.index(&FullRange),
this_tv.disr_val,
psubsts,
d);
match *ii {
ast::MethodImplItem(ref mth) => {
let d = mk_lldecl(abi::Rust);
- let needs_body = setup_lldecl(d, mth.attrs[]);
+ let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange));
if needs_body {
trans_fn(ccx,
mth.pe_fn_decl(),
match *method {
ast::ProvidedMethod(ref mth) => {
let d = mk_lldecl(abi::Rust);
- let needs_body = setup_lldecl(d, mth.attrs[]);
+ let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange));
if needs_body {
trans_fn(ccx, mth.pe_fn_decl(), mth.pe_body(), d,
psubsts, mth.id, &[]);
d
}
_ => {
- ccx.sess().bug(format!("can't monomorphize a {}",
- map_node)[])
+ ccx.sess().bug(format!("can't monomorphize a {:?}",
+ map_node).index(&FullRange))
}
}
}
let d = mk_lldecl(abi::Rust);
set_inline_hint(d);
base::trans_tuple_struct(ccx,
- struct_def.fields[],
+ struct_def.fields.index(&FullRange),
struct_def.ctor_id.expect("ast-mapped tuple struct \
didn't have a ctor id"),
psubsts,
ast_map::NodeBlock(..) |
ast_map::NodePat(..) |
ast_map::NodeLocal(..) => {
- ccx.sess().bug(format!("can't monomorphize a {}",
- map_node)[])
+ ccx.sess().bug(format!("can't monomorphize a {:?}",
+ map_node).index(&FullRange))
}
};
}
pub fn int(ccx: &CrateContext) -> Type {
- match ccx.tcx().sess.target.target.target_word_size[] {
+ match ccx.tcx().sess.target.target.target_word_size.index(&FullRange) {
"32" => Type::i32(ccx),
"64" => Type::i64(ccx),
tws => panic!("Unsupported target word size for int: {}", tws),
pub fn int_from_ty(ccx: &CrateContext, t: ast::IntTy) -> Type {
match t {
- ast::TyI => ccx.int_type(),
+ ast::TyIs => ccx.int_type(),
ast::TyI8 => Type::i8(ccx),
ast::TyI16 => Type::i16(ccx),
ast::TyI32 => Type::i32(ccx),
pub fn uint_from_ty(ccx: &CrateContext, t: ast::UintTy) -> Type {
match t {
- ast::TyU => ccx.int_type(),
+ ast::TyUs => ccx.int_type(),
ast::TyU8 => Type::i8(ccx),
ast::TyU16 => Type::i16(ccx),
ast::TyU32 => Type::i32(ccx),
use trans::common::*;
use trans::foreign;
use trans::machine;
-use middle::ty::{self, Ty};
+use middle::ty::{self, RegionEscape, Ty};
use util::ppaux;
use util::ppaux::Repr;
pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
llenvironment_type: Option<Type>,
- inputs: &[Ty<'tcx>],
- output: ty::FnOutput<'tcx>,
+ sig: &ty::Binder<ty::FnSig<'tcx>>,
abi: abi::Abi)
- -> Type {
+ -> Type
+{
+ let sig = ty::erase_late_bound_regions(cx.tcx(), sig);
+ assert!(!sig.variadic); // rust fns are never variadic
+
let mut atys: Vec<Type> = Vec::new();
// First, munge the inputs, if this has the `rust-call` ABI.
- let inputs = untuple_arguments_if_necessary(cx, inputs, abi);
+ let inputs = untuple_arguments_if_necessary(cx, sig.inputs.as_slice(), abi);
// Arg 0: Output pointer.
// (if the output type is non-immediate)
- let lloutputtype = match output {
+ let lloutputtype = match sig.output {
ty::FnConverging(output) => {
let use_out_pointer = return_uses_outptr(cx, output);
let lloutputtype = arg_type_of(cx, output);
let input_tys = inputs.iter().map(|&arg_ty| type_of_explicit_arg(cx, arg_ty));
atys.extend(input_tys);
- Type::func(atys[], &lloutputtype)
+ Type::func(atys.index(&FullRange), &lloutputtype)
}
// Given a function type and a count of ty params, construct an llvm type
// FIXME(#19925) once fn item types are
// zero-sized, we'll need to do something here
if f.abi == abi::Rust || f.abi == abi::RustCall {
- type_of_rust_fn(cx,
- None,
- f.sig.0.inputs.as_slice(),
- f.sig.0.output,
- f.abi)
+ type_of_rust_fn(cx, None, &f.sig, f.abi)
} else {
foreign::lltype_for_foreign_fn(cx, fty)
}
let llsizingty = match t.sty {
_ if !lltype_is_sized(cx.tcx(), t) => {
cx.sess().bug(format!("trying to take the sizing type of {}, an unsized type",
- ppaux::ty_to_string(cx.tcx(), t))[])
+ ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange))
}
ty::ty_bool => Type::bool(cx),
ty::ty_projection(..) | ty::ty_infer(..) | ty::ty_param(..) | ty::ty_err(..) => {
cx.sess().bug(format!("fictitious type {} in sizing_type_of()",
- ppaux::ty_to_string(cx.tcx(), t))[])
+ ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange))
}
ty::ty_vec(_, None) | ty::ty_trait(..) | ty::ty_str => panic!("unreachable")
};
}
match unsized_part_of_type(cx.tcx(), t).sty {
- ty::ty_str | ty::ty_vec(..) => Type::uint_from_ty(cx, ast::TyU),
+ ty::ty_str | ty::ty_vec(..) => Type::uint_from_ty(cx, ast::TyUs),
ty::ty_trait(_) => Type::vtable_ptr(cx),
_ => panic!("Unexpected type returned from unsized_part_of_type : {}",
t.repr(cx.tcx()))
None => ()
}
- debug!("type_of {} {}", t.repr(cx.tcx()), t.sty);
+ debug!("type_of {} {:?}", t.repr(cx.tcx()), t.sty);
+
+ assert!(!t.has_escaping_regions());
// Replace any typedef'd types with their equivalent non-typedef
// type. This ensures that all LLVM nominal types that contain
// Rust types are defined as the same LLVM types. If we don't do
// this then, e.g. `Option<{myfield: bool}>` would be a different
// type than `Option<myrec>`.
- let t_norm = ty::normalize_ty(cx.tcx(), t);
+ let t_norm = normalize_ty(cx.tcx(), t);
if t != t_norm {
let llty = type_of(cx, t_norm);
- debug!("--> normalized {} {} to {} {} llty={}",
+ debug!("--> normalized {} {:?} to {} {:?} llty={}",
t.repr(cx.tcx()),
t,
t_norm.repr(cx.tcx()),
let repr = adt::represent_type(cx, t);
let tps = substs.types.get_slice(subst::TypeSpace);
let name = llvm_type_name(cx, an_enum, did, tps);
- adt::incomplete_type_of(cx, &*repr, name[])
+ adt::incomplete_type_of(cx, &*repr, name.index(&FullRange))
}
ty::ty_unboxed_closure(did, _, ref substs) => {
// Only create the named struct, but don't fill it in. We
// contents of the VecPerParamSpace to to construct the llvm
// name
let name = llvm_type_name(cx, an_unboxed_closure, did, substs.types.as_slice());
- adt::incomplete_type_of(cx, &*repr, name[])
+ adt::incomplete_type_of(cx, &*repr, name.index(&FullRange))
}
ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => {
let repr = adt::represent_type(cx, t);
let tps = substs.types.get_slice(subst::TypeSpace);
let name = llvm_type_name(cx, a_struct, did, tps);
- adt::incomplete_type_of(cx, &*repr, name[])
+ adt::incomplete_type_of(cx, &*repr, name.index(&FullRange))
}
}
}
ty::ty_trait(..) => Type::opaque_trait(cx),
_ => cx.sess().bug(format!("ty_open with sized type: {}",
- ppaux::ty_to_string(cx.tcx(), t))[])
+ ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange))
},
ty::ty_infer(..) => cx.sess().bug("type_of with ty_infer"),
ty::ty_err(..) => cx.sess().bug("type_of with ty_err"),
};
- debug!("--> mapped t={} {} to llty={}",
+ debug!("--> mapped t={} {:?} to llty={}",
t.repr(cx.tcx()),
t,
cx.tn().type_to_string(llty));
let tstr = if strings.is_empty() {
base
} else {
- format!("{}<{}>", base, strings)
+ format!("{}<{:?}>", base, strings)
};
if did.krate == 0 {
help_name
} else {
format!("one of {}'s {} elided lifetimes", help_name, n)
- }[]);
+ }.index(&FullRange));
if len == 2 && i == 0 {
m.push_str(" or ");
format!("wrong number of type arguments: {} {}, found {}",
expected,
required_ty_param_count,
- supplied_ty_param_count)[]);
+ supplied_ty_param_count).index(&FullRange));
} else if supplied_ty_param_count > formal_ty_param_count {
let expected = if required_ty_param_count < formal_ty_param_count {
"expected at most"
format!("wrong number of type arguments: {} {}, found {}",
expected,
formal_ty_param_count,
- supplied_ty_param_count)[]);
+ supplied_ty_param_count).index(&FullRange));
}
let mut substs = Substs::new_type(types, regions);
}
}
- for param in ty_param_defs[supplied_ty_param_count..].iter() {
+ for param in ty_param_defs.index(&(supplied_ty_param_count..)).iter() {
match param.default {
Some(default) => {
// This is a default type parameter.
_ => {
this.tcx().sess.span_fatal(
ast_trait_ref.path.span,
- format!("`{}` is not a trait", ast_trait_ref.path.user_string(this.tcx()))[]);
+ format!("`{}` is not a trait",
+ ast_trait_ref.path.user_string(this.tcx())).index(&FullRange));
}
}
}
mut projections: Option<&mut Vec<ty::ProjectionPredicate<'tcx>>>)
-> Rc<ty::TraitRef<'tcx>>
{
- debug!("ast_path_to_trait_ref {}", path);
+ debug!("ast_path_to_trait_ref {:?}", path);
let trait_def = this.get_trait_def(trait_def_id);
// the trait reference introduces a binding level here, so
.sess
.span_bug(ast_ty.span,
format!("unbound path {}",
- path.repr(this.tcx()))[])
+ path.repr(this.tcx())).index(&FullRange))
}
Some(&d) => d
};
this.tcx().sess.span_bug(
path.span,
format!("converting `Box` to `{}`",
- ty.repr(this.tcx()))[]);
+ ty.repr(this.tcx())).index(&FullRange));
}
}
}
ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty), None)
}
ast::TyObjectSum(ref ty, ref bounds) => {
- match ast_ty_to_trait_ref(this, rscope, &**ty, bounds[]) {
+ match ast_ty_to_trait_ref(this, rscope, &**ty, bounds.index(&FullRange)) {
Ok((trait_ref, projection_bounds)) => {
- trait_ref_to_object_type(this, rscope, ast_ty.span,
- trait_ref, projection_bounds, bounds[])
+ trait_ref_to_object_type(this,
+ rscope,
+ ast_ty.span,
+ trait_ref,
+ projection_bounds,
+ bounds.index(&FullRange))
}
Err(ErrorReported) => {
this.tcx().types.err
ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(bare_fn))
}
ast::TyPolyTraitRef(ref bounds) => {
- conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds[])
+ conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds.index(&FullRange))
}
ast::TyPath(ref path, id) => {
let a_def = match tcx.def_map.borrow().get(&id) {
tcx.sess
.span_bug(ast_ty.span,
format!("unbound path {}",
- path.repr(tcx))[])
+ path.repr(tcx)).index(&FullRange))
}
Some(&d) => d
};
def::DefMod(id) => {
tcx.sess.span_fatal(ast_ty.span,
format!("found module name used as a type: {}",
- tcx.map.node_to_string(id.node))[]);
+ tcx.map.node_to_string(id.node)).index(&FullRange));
}
def::DefPrimTy(_) => {
panic!("DefPrimTy arm missed in previous ast_ty_to_prim_ty call");
.last()
.unwrap()
.identifier)
- .get())[]);
+ .get()).index(&FullRange));
this.tcx().types.err
}
def::DefAssociatedPath(provenance, assoc_ident) => {
_ => {
tcx.sess.span_fatal(ast_ty.span,
format!("found value name used \
- as a type: {}",
- a_def)[]);
+ as a type: {:?}",
+ a_def).index(&FullRange));
}
}
}
ast_ty.span,
format!("expected constant expr for array \
length: {}",
- *r)[]);
+ *r).index(&FullRange));
}
}
}
let input_params = if self_ty.is_some() {
decl.inputs.slice_from(1)
} else {
- decl.inputs[]
+ decl.inputs.index(&FullRange)
};
let input_tys = input_params.iter().map(|a| ty_of_arg(this, &rb, a, None));
let input_pats: Vec<String> = input_params.iter()
ast_bounds: &[ast::TyParamBound])
-> Ty<'tcx>
{
- let mut partitioned_bounds = partition_bounds(this.tcx(), span, ast_bounds[]);
+ let mut partitioned_bounds = partition_bounds(this.tcx(), span, ast_bounds.index(&FullRange));
let mut projection_bounds = Vec::new();
let main_trait_bound = if !partitioned_bounds.trait_bounds.is_empty() {
this.tcx().sess.span_err(
b.trait_ref.path.span,
format!("only the builtin traits can be used \
- as closure or object bounds")[]);
+ as closure or object bounds").index(&FullRange));
}
let region_bound = compute_region_bound(this,
builtin_bounds: ty::BuiltinBounds)
-> Option<ty::Region>
{
- debug!("compute_opt_region_bound(explicit_region_bounds={}, \
+ debug!("compute_opt_region_bound(explicit_region_bounds={:?}, \
principal_trait_ref={}, builtin_bounds={})",
explicit_region_bounds,
principal_trait_ref.repr(tcx),
tcx.sess.span_err(
span,
format!("ambiguous lifetime bound, \
- explicit lifetime bound required")[]);
+ explicit lifetime bound required").index(&FullRange));
}
return Some(r);
}
None => {
this.tcx().sess.span_err(
span,
- format!("explicit lifetime bound required")[]);
+ format!("explicit lifetime bound required").index(&FullRange));
ty::ReStatic
}
}
ast::PatRegion(ref inner, mutbl) => {
let inner_ty = fcx.infcx().next_ty_var();
- // SNAP b2085d9 remove this `if`-`else` entirely after next snapshot
+ // SNAP 340ac04 remove this `if`-`else` entirely after next snapshot
let mutbl = if mutbl == ast::MutImmutable {
ty::deref(fcx.infcx().shallow_resolve(expected), true)
.map(|mt| mt.mutbl).unwrap_or(ast::MutImmutable)
let ctor_scheme = ty::lookup_item_type(tcx, enum_def);
let path_scheme = if ty::is_fn_ty(ctor_scheme.ty) {
+ let fn_ret = ty::assert_no_late_bound_regions(tcx, &ty::ty_fn_ret(ctor_scheme.ty));
ty::TypeScheme {
- ty: ty::ty_fn_ret(ctor_scheme.ty).unwrap(),
- ..ctor_scheme
+ ty: fn_ret.unwrap(),
+ generics: ctor_scheme.generics,
}
} else {
ctor_scheme
// Typecheck each field.
for &Spanned { node: ref field, span } in fields.iter() {
- let field_type = match used_fields.entry(&field.ident.name) {
+ let field_type = match used_fields.entry(field.ident.name) {
Occupied(occupied) => {
span_err!(tcx.sess, span, E0025,
"field `{}` bound multiple times in the pattern",
let arg_exprs: Vec<_> = arg_exprs.iter().collect(); // for some weird reason we take &[&P<...>].
check_argument_types(fcx,
call_expr.span,
- fn_sig.inputs[],
+ fn_sig.inputs.as_slice(),
arg_exprs.as_slice(),
AutorefArgs::No,
fn_sig.variadic,
expected_sig: Option<ty::FnSig<'tcx>>) {
let expr_def_id = ast_util::local_def(expr.id);
- debug!("check_unboxed_closure kind={} expected_sig={}",
+ debug!("check_unboxed_closure kind={:?} expected_sig={}",
kind,
expected_sig.repr(fcx.tcx()));
// the `unboxed_closures` table.
fn_ty.sig.0.inputs = vec![ty::mk_tup(fcx.tcx(), fn_ty.sig.0.inputs)];
- debug!("unboxed_closure for {} --> sig={} kind={}",
+ debug!("unboxed_closure for {} --> sig={} kind={:?}",
expr_def_id.repr(fcx.tcx()),
fn_ty.sig.repr(fcx.tcx()),
kind);
None => { return None; }
};
- debug!("found object type {}", kind);
+ debug!("found object type {:?}", kind);
let arg_param_ty = *trait_ref.substs().types.get(subst::TypeSpace, 0);
let arg_param_ty = fcx.infcx().resolve_type_vars_if_possible(&arg_param_ty);
match pick.kind {
probe::InherentImplPick(impl_def_id) => {
assert!(ty::impl_trait_ref(self.tcx(), impl_def_id).is_none(),
- "impl {} is not an inherent impl", impl_def_id);
+ "impl {:?} is not an inherent impl", impl_def_id);
let impl_polytype = check::impl_self_ty(self.fcx, self.span, impl_def_id);
(impl_polytype.substs, MethodStatic(pick.method_ty.def_id))
self.tcx().sess.span_bug(
self.span,
format!("self-type `{}` for ObjectPick never dereferenced to an object",
- self_ty.repr(self.tcx()))[])
+ self_ty.repr(self.tcx())).index(&FullRange))
}
}
}
format!(
"{} was a subtype of {} but now is not?",
self_ty.repr(self.tcx()),
- method_self_ty.repr(self.tcx()))[]);
+ method_self_ty.repr(self.tcx())).index(&FullRange));
}
}
}
self.fcx.adjust_expr_ty(
&**base_expr,
Some(&ty::AdjustDerefRef(base_adjustment.clone())));
+ let index_expr_ty = self.fcx.expr_ty(&**index_expr);
let result = check::try_index_step(
self.fcx,
&**base_expr,
adjusted_base_ty,
base_adjustment,
- PreferMutLvalue);
+ PreferMutLvalue,
+ index_expr_ty);
if let Some((input_ty, return_ty)) = result {
- let index_expr_ty = self.fcx.expr_ty(&**index_expr);
demand::suptype(self.fcx, index_expr.span, input_ty, index_expr_ty);
let expr_ty = self.fcx.expr_ty(&**expr);
self.span,
format!("cannot upcast `{}` to `{}`",
source_trait_ref.repr(self.tcx()),
- target_trait_def_id.repr(self.tcx()))[]);
+ target_trait_def_id.repr(self.tcx())).as_slice());
}
}
}
Some(self_expr) => {
debug!("lookup_in_trait_adjusted: inserting adjustment if needed \
- (self-id={}, base adjustment={}, explicit_self={})",
+ (self-id={}, base adjustment={:?}, explicit_self={:?})",
self_expr.id, autoderefref, method_ty.explicit_self);
match method_ty.explicit_self {
span,
format!(
"trait method is &self but first arg is: {}",
- transformed_self_ty.repr(fcx.tcx()))[]);
+ transformed_self_ty.repr(fcx.tcx())).index(&FullRange));
}
}
}
fcx.tcx().sess.span_bug(
span,
format!(
- "unexpected explicit self type in operator method: {}",
- method_ty.explicit_self)[]);
+ "unexpected explicit self type in operator method: {:?}",
+ method_ty.explicit_self).index(&FullRange));
}
}
}
if is_field {
cx.sess.span_note(span,
format!("use `(s.{0})(...)` if you meant to call the \
- function stored in the `{0}` field", method_ustring)[]);
+ function stored in the `{0}` field", method_ustring).index(&FullRange));
}
if static_sources.len() > 0 {
return; // already visited
}
- debug!("assemble_inherent_impl_probe {}", impl_def_id);
+ debug!("assemble_inherent_impl_probe {:?}", impl_def_id);
let method = match impl_method(self.tcx(), impl_def_id, self.method_name) {
Some(m) => m,
self.tcx().sess.span_bug(
self.span,
format!("No entry for unboxed closure: {}",
- closure_def_id.repr(self.tcx()))[]);
+ closure_def_id.repr(self.tcx())).index(&FullRange));
}
};
debug!("pick_method(self_ty={})", self.infcx().ty_to_string(self_ty));
debug!("searching inherent candidates");
- match self.consider_candidates(self_ty, self.inherent_candidates[]) {
+ match self.consider_candidates(self_ty, self.inherent_candidates.index(&FullRange)) {
None => {}
Some(pick) => {
return Some(pick);
}
debug!("searching extension candidates");
- self.consider_candidates(self_ty, self.extension_candidates[])
+ self.consider_candidates(self_ty, self.extension_candidates.index(&FullRange))
}
fn consider_candidates(&self,
debug!("applicable_candidates: {}", applicable_candidates.repr(self.tcx()));
if applicable_candidates.len() > 1 {
- match self.collapse_candidates_to_trait_pick(applicable_candidates[]) {
+ match self.collapse_candidates_to_trait_pick(applicable_candidates.index(&FullRange)) {
Some(pick) => { return Some(Ok(pick)); }
None => { }
}
Some(data) => data,
None => return None,
};
- if probes[1..].iter().any(|p| p.to_trait_data() != Some(trait_data)) {
+ if probes.index(&(1..)).iter().any(|p| p.to_trait_data() != Some(trait_data)) {
return None;
}
-> Option<(uint, Rc<ty::Method<'tcx>>)>
{
let trait_items = ty::trait_items(tcx, trait_def_id);
- debug!("trait_method; items: {}", trait_items);
+ debug!("trait_method; items: {:?}", trait_items);
trait_items
.iter()
.filter(|item|
impl<'tcx> Repr<'tcx> for CandidateStep<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
- format!("CandidateStep({},{})",
+ format!("CandidateStep({},{:?})",
self.self_ty.repr(tcx),
self.adjustment)
}
impl<'tcx> Repr<'tcx> for PickAdjustment {
fn repr(&self, _tcx: &ty::ctxt) -> String {
- format!("{}", self)
+ format!("{:?}", self)
}
}
impl<'tcx> Repr<'tcx> for PickKind<'tcx> {
fn repr(&self, _tcx: &ty::ctxt) -> String {
- format!("{}", self)
+ format!("{:?}", self)
}
}
impl<'tcx> Repr<'tcx> for Pick<'tcx> {
fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
- format!("Pick(method_ty={}, adjustment={}, kind={})",
+ format!("Pick(method_ty={}, adjustment={:?}, kind={:?})",
self.method_ty.repr(tcx),
self.adjustment,
self.kind)
let tcx = ccx.tcx;
let err_count_on_creation = tcx.sess.err_count();
- let arg_tys = fn_sig.inputs[];
+ let arg_tys = fn_sig.inputs.index(&FullRange);
let ret_ty = fn_sig.output;
debug!("check_fn(arg_tys={}, ret_ty={}, fn_id={})",
ast::ItemEnum(ref enum_definition, _) => {
check_enum_variants(ccx,
it.span,
- enum_definition.variants[],
+ enum_definition.variants.index(&FullRange),
it.id);
}
ast::ItemFn(ref decl, _, _, _, ref body) => {
but not in the trait",
token::get_name(trait_m.name),
ppaux::explicit_self_category_to_str(
- &impl_m.explicit_self))[]);
+ &impl_m.explicit_self)).index(&FullRange));
return;
}
(_, &ty::StaticExplicitSelfCategory) => {
but not in the impl",
token::get_name(trait_m.name),
ppaux::explicit_self_category_to_str(
- &trait_m.explicit_self))[]);
+ &trait_m.explicit_self)).index(&FullRange));
return;
}
_ => {
span,
format!("lifetime parameters or bounds on method `{}` do \
not match the trait declaration",
- token::get_name(impl_m.name))[]);
+ token::get_name(impl_m.name)).index(&FullRange));
return false;
}
from its counterpart `{}` \
declared in the trait",
impl_param.name.user_string(tcx),
- trait_param.name.user_string(tcx))[]);
+ trait_param.name.user_string(tcx)).index(&FullRange));
true
} else {
false
tcx.sess.span_note(
span,
format!("the impl is missing the following bounds: `{}`",
- missing.user_string(tcx))[]);
+ missing.user_string(tcx)).index(&FullRange));
}
if extra.len() != 0 {
tcx.sess.span_note(
span,
format!("the impl has the following extra bounds: `{}`",
- extra.user_string(tcx))[]);
+ extra.user_string(tcx)).index(&FullRange));
}
if err {
}
pub fn tag(&self) -> String {
- format!("{}", self as *const FnCtxt)
+ format!("{:?}", self as *const FnCtxt)
}
pub fn local_ty(&self, span: Span, nid: ast::NodeId) -> Ty<'tcx> {
self.tcx().sess.span_bug(
span,
format!("no type for local variable {}",
- nid)[]);
+ nid).index(&FullRange));
}
}
}
fn register_unsize_obligations(&self,
span: Span,
unsize: &ty::UnsizeKind<'tcx>) {
- debug!("register_unsize_obligations: unsize={}", unsize);
+ debug!("register_unsize_obligations: unsize={:?}", unsize);
match *unsize {
ty::UnsizeLength(..) => {}
Some(&t) => t,
None => {
self.tcx().sess.bug(format!("no type for expr in fcx {}",
- self.tag())[]);
+ self.tag()).index(&FullRange));
}
}
}
self.tcx().sess.bug(
format!("no type for node {}: {} in fcx {}",
id, self.tcx().map.node_to_string(id),
- self.tag())[]);
+ self.tag()).index(&FullRange));
}
}
}
{
match method {
Some(method) => {
- let ref_ty = ty::ty_fn_ret(method.ty);
+ let ref_ty = // invoked methods have all LB regions instantiated
+ ty::assert_no_late_bound_regions(
+ fcx.tcx(), &ty::ty_fn_ret(method.ty));
match method_call {
Some(method_call) => {
fcx.inh.method_map.borrow_mut().insert(method_call,
}
}
-/// Checks for a `Slice` (or `SliceMut`) impl at the relevant level of autoderef. If it finds one,
-/// installs method info and returns type of method (else None).
-fn try_overloaded_slice_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- method_call: MethodCall,
- expr: &ast::Expr,
- base_expr: &ast::Expr,
- base_ty: Ty<'tcx>, // autoderef'd type
- autoderefref: ty::AutoDerefRef<'tcx>,
- lvalue_pref: LvaluePreference,
- start_expr: &Option<P<ast::Expr>>,
- end_expr: &Option<P<ast::Expr>>)
- -> Option<(Ty<'tcx>, /* index type */
- Ty<'tcx>)> /* return type */
-{
- let input_ty = fcx.infcx().next_ty_var();
- let return_ty = fcx.infcx().next_ty_var();
-
- let method = match lvalue_pref {
- PreferMutLvalue => {
- // Try `SliceMut` first, if preferred.
- match fcx.tcx().lang_items.slice_mut_trait() {
- Some(trait_did) => {
- let method_name = match (start_expr, end_expr) {
- (&Some(_), &Some(_)) => "slice_or_fail_mut",
- (&Some(_), &None) => "slice_from_or_fail_mut",
- (&None, &Some(_)) => "slice_to_or_fail_mut",
- (&None, &None) => "as_mut_slice_",
- };
-
- method::lookup_in_trait_adjusted(fcx,
- expr.span,
- Some(&*base_expr),
- token::intern(method_name),
- trait_did,
- autoderefref,
- base_ty,
- Some(vec![input_ty, return_ty]))
- }
- _ => None,
- }
- }
- NoPreference => {
- // Otherwise, fall back to `Slice`.
- match fcx.tcx().lang_items.slice_trait() {
- Some(trait_did) => {
- let method_name = match (start_expr, end_expr) {
- (&Some(_), &Some(_)) => "slice_or_fail",
- (&Some(_), &None) => "slice_from_or_fail",
- (&None, &Some(_)) => "slice_to_or_fail",
- (&None, &None) => "as_slice_",
- };
-
- method::lookup_in_trait_adjusted(fcx,
- expr.span,
- Some(&*base_expr),
- token::intern(method_name),
- trait_did,
- autoderefref,
- base_ty,
- Some(vec![input_ty, return_ty]))
- }
- _ => None,
- }
- }
- };
-
- // If some lookup succeeded, install method in table
- method.map(|method| {
- let method_ty = method.ty;
- make_overloaded_lvalue_return_type(fcx, Some(method_call), Some(method));
-
- let result_ty = ty::ty_fn_ret(method_ty);
- let result_ty = match result_ty {
- ty::FnConverging(result_ty) => result_ty,
- ty::FnDiverging => {
- fcx.tcx().sess.span_bug(expr.span,
- "slice trait does not define a `!` return")
- }
- };
-
- (input_ty, result_ty)
- })
-}
-
/// To type-check `base_expr[index_expr]`, we progressively autoderef (and otherwise adjust)
/// `base_expr`, looking for a type which either supports builtin indexing or overloaded indexing.
/// This loop implements one step in that search; the autoderef loop is implemented by
base_expr: &ast::Expr,
adjusted_ty: Ty<'tcx>,
adjustment: ty::AutoDerefRef<'tcx>,
- lvalue_pref: LvaluePreference)
+ lvalue_pref: LvaluePreference,
+ index_ty: Ty<'tcx>)
-> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
{
- debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, adjustment={})",
- expr.repr(fcx.tcx()),
- base_expr.repr(fcx.tcx()),
- adjusted_ty.repr(fcx.tcx()),
- adjustment);
-
- // Try built-in indexing first.
- match ty::index(adjusted_ty) {
- Some(ty) => {
+ let tcx = fcx.tcx();
+ debug!("try_index_step(expr={}, base_expr.id={}, adjusted_ty={}, adjustment={:?}, index_ty={})",
+ expr.repr(tcx),
+ base_expr.repr(tcx),
+ adjusted_ty.repr(tcx),
+ adjustment,
+ index_ty.repr(tcx));
+
+ let input_ty = fcx.infcx().next_ty_var();
+
+ // First, try built-in indexing.
+ match (ty::index(adjusted_ty), &index_ty.sty) {
+ (Some(ty), &ty::ty_uint(ast::TyUs)) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => {
+ debug!("try_index_step: success, using built-in indexing");
fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment));
- return Some((fcx.tcx().types.uint, ty));
+ return Some((tcx.types.uint, ty));
}
-
- None => { }
+ _ => {}
}
- let input_ty = fcx.infcx().next_ty_var();
-
// Try `IndexMut` first, if preferred.
- let method = match (lvalue_pref, fcx.tcx().lang_items.index_mut_trait()) {
+ let method = match (lvalue_pref, tcx.lang_items.index_mut_trait()) {
(PreferMutLvalue, Some(trait_did)) => {
method::lookup_in_trait_adjusted(fcx,
expr.span,
};
// Otherwise, fall back to `Index`.
- let method = match (method, fcx.tcx().lang_items.index_trait()) {
+ let method = match (method, tcx.lang_items.index_trait()) {
(None, Some(trait_did)) => {
method::lookup_in_trait_adjusted(fcx,
expr.span,
Some(&*base_expr),
token::intern("index"),
trait_did,
- adjustment,
+ adjustment.clone(),
adjusted_ty,
Some(vec![input_ty]))
}
// type from the method signature.
// If some lookup succeeded, install method in table
method.and_then(|method| {
+ debug!("try_index_step: success, using overloaded indexing");
make_overloaded_lvalue_return_type(fcx, Some(method_call), Some(method)).
map(|ret| (input_ty, ret.ty))
})
Ok(trait_did) => trait_did,
Err(ref err_string) => {
fcx.tcx().sess.span_err(iterator_expr.span,
- err_string[]);
+ err_string.index(&FullRange));
return fcx.tcx().types.err
}
};
format!("`for` loop expression has type `{}` which does \
not implement the `Iterator` trait; \
maybe try .iter()",
- ty_string)[]);
+ ty_string).index(&FullRange));
}
fcx.tcx().types.err
}
format!("`next` method of the `Iterator` \
trait has an unexpected type `{}`",
fcx.infcx().ty_to_string(return_type))
- []);
+ .index(&FullRange));
fcx.tcx().types.err
}
}
check_argument_types(fcx,
sp,
- err_inputs[],
+ err_inputs.index(&FullRange),
args_no_rcvr,
autoref_args,
false,
err_args(fcx.tcx(), supplied_arg_count)
};
- debug!("check_argument_types: formal_tys={}",
+ debug!("check_argument_types: formal_tys={:?}",
formal_tys.iter().map(|t| fcx.infcx().ty_to_string(*t)).collect::<Vec<String>>());
// Check the arguments.
};
// Call the generic checker.
- let args: Vec<_> = args[1..].iter().map(|x| x).collect();
+ let args: Vec<_> = args.index(&(1..)).iter().map(|x| x).collect();
let ret_ty = check_method_argument_types(fcx,
method_name.span,
fn_ty,
}
};
- debug!("adjusted_ty={} adjustment={}",
+ debug!("adjusted_ty={} adjustment={:?}",
adj_ty.repr(fcx.tcx()),
adjustment);
ty::ty_struct(base_id, substs) => {
debug!("struct named {}", ppaux::ty_to_string(tcx, base_t));
let fields = ty::lookup_struct_fields(tcx, base_id);
- lookup_field_ty(tcx, base_id, fields[],
+ lookup_field_ty(tcx, base_id, fields.index(&FullRange),
field.node.name, &(*substs))
}
_ => None
if tuple_like {
debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t));
let fields = ty::lookup_struct_fields(tcx, base_id);
- lookup_tup_field_ty(tcx, base_id, fields[],
+ lookup_tup_field_ty(tcx, base_id, fields.index(&FullRange),
idx.node, &(*substs))
} else {
None
class_id,
id,
fcx.ccx.tcx.mk_substs(struct_substs),
- class_fields[],
+ class_fields.index(&FullRange),
fields,
base_expr.is_none(),
None);
variant_id,
id,
fcx.ccx.tcx.mk_substs(substitutions),
- variant_fields[],
+ variant_fields.index(&FullRange),
fields,
true,
Some(enum_id));
callee::check_call(fcx, expr, &**callee, args.as_slice());
}
ast::ExprMethodCall(ident, ref tps, ref args) => {
- check_method_call(fcx, expr, ident, args[], tps[], lvalue_pref);
+ check_method_call(fcx, expr, ident, args.as_slice(), tps.as_slice(), lvalue_pref);
let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a));
let args_err = arg_tys.fold(false,
|rest_err, a| {
let expected = expected.only_has_type();
let flds = expected.map_to_option(fcx, |ty| {
match ty.sty {
- ty::ty_tup(ref flds) => Some(flds[]),
+ ty::ty_tup(ref flds) => Some(flds.index(&FullRange)),
_ => None
}
});
let struct_id = match def {
Some(def::DefVariant(enum_id, variant_id, true)) => {
check_struct_enum_variant(fcx, id, expr.span, enum_id,
- variant_id, fields[]);
+ variant_id, fields.index(&FullRange));
enum_id
}
Some(def::DefTrait(def_id)) => {
pprust::path_to_string(path));
check_struct_fields_on_error(fcx,
id,
- fields[],
+ fields.index(&FullRange),
base_expr);
def_id
},
id,
expr.span,
struct_did,
- fields[],
+ fields.index(&FullRange),
base_expr.as_ref().map(|e| &**e));
}
_ => {
pprust::path_to_string(path));
check_struct_fields_on_error(fcx,
id,
- fields[],
+ fields.index(&FullRange),
base_expr);
}
}
fcx.infcx()
.ty_to_string(
actual_structure_type),
- type_error_description)[]);
+ type_error_description).index(&FullRange));
ty::note_and_explain_type_err(tcx, &type_error);
}
}
if ty::type_is_error(base_t) {
fcx.write_ty(id, base_t);
} else {
- match idx.node {
- ast::ExprRange(ref start, ref end) => {
- // A slice, rather than an index. Special cased for now (KILLME).
+ check_expr(fcx, &**idx);
+ let idx_t = fcx.expr_ty(&**idx);
+ if ty::type_is_error(idx_t) {
+ fcx.write_ty(id, idx_t);
+ } else {
let base_t = structurally_resolved_type(fcx, expr.span, base_t);
let result =
autoderef_for_index(fcx, &**base, base_t, lvalue_pref, |adj_ty, adj| {
- try_overloaded_slice_step(fcx,
- MethodCall::expr(expr.id),
- expr,
- &**base,
- adj_ty,
- adj,
- lvalue_pref,
- start,
- end)
+ try_index_step(fcx,
+ MethodCall::expr(expr.id),
+ expr,
+ &**base,
+ adj_ty,
+ adj,
+ lvalue_pref,
+ idx_t)
});
- let mut args = vec![];
- start.as_ref().map(|x| args.push(x));
- end.as_ref().map(|x| args.push(x));
-
match result {
Some((index_ty, element_ty)) => {
- for a in args.iter() {
- check_expr_has_type(fcx, &***a, index_ty);
- }
- fcx.write_ty(idx.id, element_ty);
- fcx.write_ty(id, element_ty)
+ // FIXME: we've already checked idx above, we should
+ // probably just demand subtype or something here.
+ check_expr_has_type(fcx, &**idx, index_ty);
+ fcx.write_ty(id, element_ty);
}
_ => {
- for a in args.iter() {
- check_expr(fcx, &***a);
- }
- fcx.type_error_message(expr.span,
- |actual| {
- format!("cannot take a slice of a value with type `{}`",
+ check_expr_has_type(fcx, &**idx, fcx.tcx().types.err);
+ fcx.type_error_message(
+ expr.span,
+ |actual| {
+ format!("cannot index a value of type `{}`",
actual)
- },
- base_t,
- None);
- fcx.write_ty(idx.id, fcx.tcx().types.err);
+ },
+ base_t,
+ None);
fcx.write_ty(id, fcx.tcx().types.err);
}
}
- }
- _ => {
- check_expr(fcx, &**idx);
- let idx_t = fcx.expr_ty(&**idx);
- if ty::type_is_error(idx_t) {
- fcx.write_ty(id, idx_t);
- } else {
- let base_t = structurally_resolved_type(fcx, expr.span, base_t);
-
- let result =
- autoderef_for_index(fcx, &**base, base_t, lvalue_pref, |adj_ty, adj| {
- try_index_step(fcx,
- MethodCall::expr(expr.id),
- expr,
- &**base,
- adj_ty,
- adj,
- lvalue_pref)
- });
-
- match result {
- Some((index_ty, element_ty)) => {
- check_expr_has_type(fcx, &**idx, index_ty);
- fcx.write_ty(id, element_ty);
- }
- _ => {
- check_expr_has_type(fcx, &**idx, fcx.tcx().types.err);
- fcx.type_error_message(
- expr.span,
- |actual| {
- format!("cannot index a value of type `{}`",
- actual)
- },
- base_t,
- None);
- fcx.write_ty(id, fcx.tcx().types.err);
- }
- }
- }
- }
}
}
}
};
// Note that we don't check the type of start/end satisfy any
- // bounds because right the range structs do not have any. If we add
+ // bounds because right now the range structs do not have any. If we add
// some bounds, then we'll need to check `t_start` against them here.
let range_type = match idx_type {
ast::TyU16 => disr as u16 as Disr == disr,
ast::TyU32 => disr as u32 as Disr == disr,
ast::TyU64 => disr as u64 as Disr == disr,
- ast::TyU => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr)
+ ast::TyUs => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr)
}
}
fn int_in_range(ccx: &CrateCtxt, ty: ast::IntTy, disr: ty::Disr) -> bool {
ast::TyI16 => disr as i16 as Disr == disr,
ast::TyI32 => disr as i32 as Disr == disr,
ast::TyI64 => disr as i64 as Disr == disr,
- ast::TyI => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr)
+ ast::TyIs => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr)
}
}
match ty {
}
let hint = *ty::lookup_repr_hints(ccx.tcx, ast::DefId { krate: ast::LOCAL_CRATE, node: id })
- [].get(0).unwrap_or(&attr::ReprAny);
+ .index(&FullRange).get(0).unwrap_or(&attr::ReprAny);
if hint != attr::ReprAny && vs.len() <= 1 {
if vs.len() == 1 {
}
assert_eq!(segment_spaces.len(), path.segments.len());
- debug!("segment_spaces={}", segment_spaces);
+ debug!("segment_spaces={:?}", segment_spaces);
// Next, examine the definition, and determine how many type
// parameters we expect from each space.
.take_while(|d| d.default.is_none())
.count();
- debug!("adjust_type_parameters(space={}, \
+ debug!("adjust_type_parameters(space={:?}, \
provided_len={}, \
desired_len={}, \
required_len={})",
"get_tydesc" => {
let tydesc_ty = match ty::get_tydesc_ty(ccx.tcx) {
Ok(t) => t,
- Err(s) => { tcx.sess.span_fatal(it.span, s[]); }
+ Err(s) => { tcx.sess.span_fatal(it.span, s.index(&FullRange)); }
};
let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
ty: tydesc_ty,
ty::mk_struct(ccx.tcx, did,
ccx.tcx.mk_substs(subst::Substs::empty()))),
Err(msg) => {
- tcx.sess.span_fatal(it.span, msg[]);
+ tcx.sess.span_fatal(it.span, msg.index(&FullRange));
}
}
},
}
}
_ => {
- tcx.sess.bug(format!("unexpected def in region_of_def: {}",
- def)[])
+ tcx.sess.bug(format!("unexpected def in region_of_def: {:?}",
+ def).index(&FullRange))
}
}
}
Some(f) => f,
None => {
self.tcx().sess.bug(
- format!("No fn-sig entry for id={}", id)[]);
+ format!("No fn-sig entry for id={}", id).index(&FullRange));
}
};
let len = self.region_bound_pairs.len();
- self.relate_free_regions(fn_sig[], body.id);
- link_fn_args(self, CodeExtent::from_node_id(body.id), fn_decl.inputs[]);
+ self.relate_free_regions(fn_sig.index(&FullRange), body.id);
+ link_fn_args(self, CodeExtent::from_node_id(body.id), fn_decl.inputs.index(&FullRange));
self.visit_block(body);
self.visit_region_obligations(body.id);
self.region_bound_pairs.truncate(len);
// Check any autoderefs or autorefs that appear.
for &adjustment in rcx.fcx.inh.adjustments.borrow().get(&expr.id).iter() {
- debug!("adjustment={}", adjustment);
+ debug!("adjustment={:?}", adjustment);
match *adjustment {
ty::AdjustDerefRef(ty::AutoDerefRef {autoderefs, autoref: ref opt_autoref}) => {
let expr_ty = rcx.resolve_node_type(expr.id);
Some(method) => {
constrain_call(rcx, expr, Some(&**base),
None::<ast::Expr>.iter(), true);
- ty::ty_fn_ret(method.ty).unwrap()
+ let fn_ret = // late-bound regions in overloaded method calls are instantiated
+ ty::assert_no_late_bound_regions(rcx.tcx(), &ty::ty_fn_ret(method.ty));
+ fn_ret.unwrap()
}
None => rcx.resolve_node_type(base.id)
};
}
ast::ExprMatch(ref discr, ref arms, _) => {
- link_match(rcx, &**discr, arms[]);
+ link_match(rcx, &**discr, arms.index(&FullRange));
visit::walk_expr(rcx, expr);
}
debug!("constrain_free_variables({}, {})",
region_bound.repr(tcx), expr.repr(tcx));
for freevar in freevars.iter() {
- debug!("freevar def is {}", freevar.def);
+ debug!("freevar def is {:?}", freevar.def);
// Identify the variable being closed over and its node-id.
let def = freevar.def;
ty::ty_rptr(r, ref m) => (m.mutbl, r),
_ => rcx.tcx().sess.span_bug(deref_expr.span,
format!("bad overloaded deref type {}",
- method.ty.repr(rcx.tcx()))[])
+ method.ty.repr(rcx.tcx())).index(&FullRange))
};
{
let mc = mc::MemCategorizationContext::new(rcx.fcx);
rcx.fcx.inh.adjustments.borrow().get(&id),
|method_call| rcx.resolve_method_type(method_call));
debug!("constrain_regions_in_type_of_node(\
- ty={}, ty0={}, id={}, minimum_lifetime={})",
+ ty={}, ty0={}, id={}, minimum_lifetime={:?})",
ty_to_string(tcx, ty), ty_to_string(tcx, ty0),
id, minimum_lifetime);
type_must_outlive(rcx, origin, ty, minimum_lifetime);
/// then ensures that the lifetime of the resulting pointer is
/// linked to the lifetime of its guarantor (if any).
fn link_fn_args(rcx: &Rcx, body_scope: CodeExtent, args: &[ast::Arg]) {
- debug!("regionck::link_fn_args(body_scope={})", body_scope);
+ debug!("regionck::link_fn_args(body_scope={:?})", body_scope);
let mc = mc::MemCategorizationContext::new(rcx.fcx);
for arg in args.iter() {
let arg_ty = rcx.fcx.node_ty(arg.id);
autoderefs: uint,
autoref: &ty::AutoRef) {
- debug!("link_autoref(autoref={})", autoref);
+ debug!("link_autoref(autoref={:?})", autoref);
let mc = mc::MemCategorizationContext::new(rcx.fcx);
let expr_cmt = ignore_err!(mc.cat_expr_autoderefd(expr, autoderefs));
debug!("expr_cmt={}", expr_cmt.repr(rcx.tcx()));
expr: &ast::Expr,
callee_scope: CodeExtent) {
let tcx = rcx.tcx();
- debug!("link_by_ref(expr={}, callee_scope={})",
+ debug!("link_by_ref(expr={}, callee_scope={:?})",
expr.repr(tcx), callee_scope);
let mc = mc::MemCategorizationContext::new(rcx.fcx);
let expr_cmt = ignore_err!(mc.cat_expr(expr));
span,
format!("Illegal upvar id: {}",
upvar_id.repr(
- rcx.tcx()))[]);
+ rcx.tcx())).index(&FullRange));
}
}
}
ty::ty_open(_) => {
self.tcx.sess.bug(
format!("Unexpected type encountered while doing wf check: {}",
- ty.repr(self.tcx))[]);
+ ty.repr(self.tcx)).index(&FullRange));
}
}
}
let var_node_id = freevar.def.local_node_id();
let upvar_id = ty::UpvarId { var_id: var_node_id,
closure_expr_id: expr.id };
- debug!("seed upvar_id {}", upvar_id);
+ debug!("seed upvar_id {:?}", upvar_id);
let origin = UpvarRegion(upvar_id, expr.span);
let freevar_region = self.infcx().next_region_var(origin);
let upvar_borrow = ty::UpvarBorrow { kind: ty::ImmBorrow,
upvar_id: ty::UpvarId,
upvar_borrow: &mut ty::UpvarBorrow,
kind: ty::BorrowKind) {
- debug!("adjust_upvar_borrow_kind: id={} kind=({} -> {})",
+ debug!("adjust_upvar_borrow_kind: id={:?} kind=({:?} -> {:?})",
upvar_id, upvar_borrow.kind, kind);
match (upvar_borrow.kind, kind) {
bk: ty::BorrowKind,
_loan_cause: euv::LoanCause)
{
- debug!("borrow(borrow_id={}, cmt={}, bk={})",
+ debug!("borrow(borrow_id={}, cmt={}, bk={:?})",
borrow_id, cmt.repr(self.tcx()), bk);
match bk {
source_expr.span,
format!("can only cast an boxed pointer \
to a boxed object, not a {}",
- ty::ty_sort_string(fcx.tcx(), source_ty))[]);
+ ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange));
}
(_, &ty::ty_rptr(..)) => {
source_expr.span,
format!("can only cast a &-pointer \
to an &-object, not a {}",
- ty::ty_sort_string(fcx.tcx(), source_ty))[]);
+ ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange));
}
_ => {
{
let ccx = self.ccx;
let item_def_id = local_def(item.id);
- let polytype = ty::lookup_item_type(ccx.tcx, item_def_id);
+ let type_scheme = ty::lookup_item_type(ccx.tcx, item_def_id);
+ reject_non_type_param_bounds(ccx.tcx, item.span, &type_scheme.generics);
let param_env =
ty::construct_parameter_environment(ccx.tcx,
- &polytype.generics,
+ &type_scheme.generics,
item.id);
let inh = Inherited::new(ccx.tcx, param_env);
- let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(polytype.ty), item.id);
+ let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(type_scheme.ty), item.id);
f(self, &fcx);
vtable::select_all_fcx_obligations_or_error(&fcx);
regionck::regionck_item(&fcx, item);
item.span,
region::CodeExtent::from_node_id(item.id),
Some(&mut this.cache));
+
let type_scheme = ty::lookup_item_type(fcx.tcx(), local_def(item.id));
let item_ty = fcx.instantiate_type_scheme(item.span,
&fcx.inh.param_env.free_substs,
&type_scheme.ty);
+
bounds_checker.check_traits_in_ty(item_ty);
});
}
None => { return; }
Some(t) => { t }
};
+
let trait_ref = fcx.instantiate_type_scheme(item.span,
&fcx.inh.param_env.free_substs,
&trait_ref);
}
}
+// Reject any predicates that do not involve a type parameter.
+fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>,
+ span: Span,
+ generics: &ty::Generics<'tcx>) {
+ for predicate in generics.predicates.iter() {
+ match predicate {
+ &ty::Predicate::Trait(ty::Binder(ref tr)) => {
+ let self_ty = tr.self_ty();
+ if !self_ty.walk().any(|t| is_ty_param(t)) {
+ tcx.sess.span_err(
+ span,
+ format!("cannot bound type `{}`, where clause \
+ bounds may only be attached to types involving \
+ type parameters",
+ self_ty.repr(tcx)).as_slice())
+ }
+ }
+ _ => {}
+ }
+ }
+
+ fn is_ty_param(ty: ty::Ty) -> bool {
+ match &ty.sty {
+ &ty::sty::ty_param(_) => true,
+ _ => false
+ }
+ }
+}
+
impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> {
fn visit_item(&mut self, i: &ast::Item) {
self.check_item_well_formed(i);
match variant.node.kind {
ast::TupleVariantKind(ref args) if args.len() > 0 => {
let ctor_ty = ty::node_id_to_type(fcx.tcx(), variant.node.id);
- let arg_tys = ty::ty_fn_args(ctor_ty);
+
+ // the regions in the argument types come from the
+ // enum def'n, and hence will all be early bound
+ let arg_tys =
+ ty::assert_no_late_bound_regions(
+ fcx.tcx(), &ty::ty_fn_args(ctor_ty));
+
AdtVariant {
fields: args.iter().enumerate().map(|(index, arg)| {
let arg_ty = arg_tys[index];
})
}
};
- debug!("Adjustments for node {}: {}", id, resolved_adjustment);
+ debug!("Adjustments for node {}: {:?}", id, resolved_adjustment);
self.tcx().adjustments.borrow_mut().insert(
id, resolved_adjustment);
}
// Resolve any method map entry
match self.fcx.inh.method_map.borrow_mut().remove(&method_call) {
Some(method) => {
- debug!("writeback::resolve_method_map_entry(call={}, entry={})",
+ debug!("writeback::resolve_method_map_entry(call={:?}, entry={})",
method_call,
method.repr(self.tcx()));
let new_method = MethodCallee {
inference_context.tcx.sess.span_bug(
span,
format!("coherence encountered unexpected type searching for base type: {}",
- ty.repr(inference_context.tcx))[]);
+ ty.repr(inference_context.tcx)).index(&FullRange));
}
}
}
trait_ref: &ty::TraitRef<'tcx>,
all_impl_items: &mut Vec<ImplOrTraitItemId>) {
let tcx = self.crate_context.tcx;
- debug!("instantiate_default_methods(impl_id={}, trait_ref={})",
+ debug!("instantiate_default_methods(impl_id={:?}, trait_ref={})",
impl_id, trait_ref.repr(tcx));
let impl_type_scheme = ty::lookup_item_type(tcx, impl_id);
let new_id = tcx.sess.next_node_id();
let new_did = local_def(new_id);
- debug!("new_did={} trait_method={}", new_did, trait_method.repr(tcx));
+ debug!("new_did={:?} trait_method={}", new_did, trait_method.repr(tcx));
// Create substitutions for the various trait parameters.
let new_method_ty =
}
fn add_trait_impl(&self, base_def_id: DefId, impl_def_id: DefId) {
- debug!("add_trait_impl: base_def_id={} impl_def_id={}",
+ debug!("add_trait_impl: base_def_id={:?} impl_def_id={:?}",
base_def_id, impl_def_id);
ty::record_trait_implementation(self.crate_context.tcx,
base_def_id,
format!("the trait `Copy` may not be \
implemented for this type; field \
`{}` does not implement `Copy`",
- token::get_name(name))[])
+ token::get_name(name)).index(&FullRange))
}
Err(ty::VariantDoesNotImplementCopy(name)) => {
tcx.sess
format!("the trait `Copy` may not be \
implemented for this type; variant \
`{}` does not implement `Copy`",
- token::get_name(name))[])
+ token::get_name(name)).index(&FullRange))
}
Err(ty::TypeIsStructural) => {
tcx.sess
use middle::region;
use middle::resolve_lifetime;
use middle::subst;
-use middle::subst::{Substs};
+use middle::subst::{Substs, TypeSpace};
use middle::ty::{AsPredicate, ImplContainer, ImplOrTraitItemContainer, TraitContainer};
use middle::ty::{self, RegionEscape, Ty, TypeScheme};
use middle::ty_fold::{self, TypeFolder, TypeFoldable};
use util::ppaux::{Repr,UserString};
use write_ty_to_tcx;
+use std::collections::HashSet;
use std::rc::Rc;
use syntax::abi;
}
x => {
self.tcx.sess.bug(format!("unexpected sort of node \
- in get_item_type_scheme(): {}",
+ in get_item_type_scheme(): {:?}",
x).as_slice());
}
}
ast::TupleVariantKind(ref args) if args.len() > 0 => {
let rs = ExplicitRscope;
let input_tys: Vec<_> = args.iter().map(|va| ccx.to_ty(&rs, &*va.ty)).collect();
- ty::mk_ctor_fn(tcx, variant_def_id, input_tys[], enum_ty)
+ ty::mk_ctor_fn(tcx, variant_def_id, input_tys.index(&FullRange), enum_ty)
}
ast::TupleVariantKind(_) => {
ccx,
trait_id,
&trait_def.generics,
- trait_items[],
+ trait_items.index(&FullRange),
&m.id,
&m.ident.name,
&m.explicit_self,
ccx,
trait_id,
&trait_def.generics,
- trait_items[],
+ trait_items.index(&FullRange),
&m.id,
&m.pe_ident().name,
m.pe_explicit_self(),
write_ty_to_tcx(tcx, m.id, fty);
- debug!("writing method type: def_id={} mty={}",
+ debug!("writing method type: def_id={:?} mty={}",
mty.def_id, mty.repr(ccx.tcx));
tcx.impl_or_trait_items
Some(selfty),
None);
}
+
+ enforce_impl_ty_params_are_constrained(ccx.tcx,
+ generics,
+ local_def(it.id));
},
ast::ItemTrait(_, _, _, ref trait_methods) => {
let trait_def = trait_def_of_item(ccx, it);
local_def(field.node.id)].ty).collect();
let ctor_fn_ty = ty::mk_ctor_fn(tcx,
local_def(ctor_id),
- inputs[],
+ inputs.index(&FullRange),
selfty);
write_ty_to_tcx(tcx, ctor_id, ctor_fn_ty);
tcx.tcache.borrow_mut().insert(local_def(ctor_id),
ast_map::NodeItem(item) => trait_def_of_item(ccx, &*item),
_ => {
ccx.tcx.sess.bug(format!("get_trait_def({}): not an item",
- trait_id.node)[])
+ trait_id.node).index(&FullRange))
}
}
}
ref s => {
tcx.sess.span_bug(
it.span,
- format!("trait_def_of_item invoked on {}", s)[]);
+ format!("trait_def_of_item invoked on {:?}", s).index(&FullRange));
}
};
-> ty::Generics<'tcx> {
ty_generics(ccx,
subst::TypeSpace,
- generics.lifetimes[],
- generics.ty_params[],
+ generics.lifetimes.index(&FullRange),
+ generics.ty_params.index(&FullRange),
ty::Generics::empty(),
&generics.where_clause)
}
let mut generics =
ty_generics(ccx,
subst::TypeSpace,
- ast_generics.lifetimes[],
- ast_generics.ty_params[],
+ ast_generics.lifetimes.index(&FullRange),
+ ast_generics.ty_params.index(&FullRange),
ty::Generics::empty(),
&ast_generics.where_clause);
let early_lifetimes = resolve_lifetime::early_bound_lifetimes(generics);
ty_generics(ccx,
subst::FnSpace,
- early_lifetimes[],
- generics.ty_params[],
+ early_lifetimes.index(&FullRange),
+ generics.ty_params.index(&FullRange),
base_generics,
&generics.where_clause)
}
index: i as u32,
def_id: local_def(l.lifetime.id),
bounds: bounds };
- debug!("ty_generics: def for region param: {}", def);
+ debug!("ty_generics: def for region param: {:?}", def);
result.regions.push(space, def);
}
space,
param,
i as u32);
- debug!("ty_generics: def for type param: {}, {}",
+ debug!("ty_generics: def for type param: {}, {:?}",
def.repr(ccx.tcx),
space);
result.types.push(space, def);
let param_ty = ty::ParamTy::new(space, index, param.ident.name);
let bounds = compute_bounds(ccx,
param_ty.to_ty(ccx.tcx),
- param.bounds[],
+ param.bounds.index(&FullRange),
SizedByDefault::Yes,
param.span);
let default = match param.default {
if !param_bounds.builtin_bounds.contains(&ty::BoundSized) {
ty::each_bound_trait_and_supertraits(
tcx,
- param_bounds.trait_bounds[],
+ param_bounds.trait_bounds.index(&FullRange),
|trait_ref| {
let trait_def = ty::lookup_trait_def(tcx, trait_ref.def_id());
if trait_def.bounds.builtin_bounds.contains(&ty::BoundSized) {
})
}
}
+
+/// Checks that all the type parameters on an impl
+fn enforce_impl_ty_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>,
+ ast_generics: &ast::Generics,
+ impl_def_id: ast::DefId)
+{
+ let impl_scheme = ty::lookup_item_type(tcx, impl_def_id);
+ let impl_trait_ref = ty::impl_trait_ref(tcx, impl_def_id);
+
+ // The trait reference is an input, so find all type parameters
+ // reachable from there, to start (if this is an inherent impl,
+ // then just examine the self type).
+ let mut input_parameters: HashSet<_> =
+ impl_trait_ref.iter()
+ .flat_map(|t| t.input_types().iter()) // Types in trait ref, if any
+ .chain(Some(impl_scheme.ty).iter()) // Self type, always
+ .flat_map(|t| t.walk())
+ .filter_map(to_opt_param_ty)
+ .collect();
+
+ loop {
+ let num_inputs = input_parameters.len();
+
+ let mut projection_predicates =
+ impl_scheme.generics.predicates
+ .iter()
+ .filter_map(|predicate| {
+ match *predicate {
+ // Ignore higher-ranked binders. For the purposes
+ // of this check, they don't matter because they
+ // only affect named regions, and we're just
+ // concerned about type parameters here.
+ ty::Predicate::Projection(ref data) => Some(data.0.clone()),
+ _ => None,
+ }
+ });
+
+ for projection in projection_predicates {
+ // Special case: watch out for some kind of sneaky attempt
+ // to project out an associated type defined by this very trait.
+ if Some(projection.projection_ty.trait_ref.clone()) == impl_trait_ref {
+ continue;
+ }
+
+ let relies_only_on_inputs =
+ projection.projection_ty.trait_ref.input_types().iter()
+ .flat_map(|t| t.walk())
+ .filter_map(to_opt_param_ty)
+ .all(|t| input_parameters.contains(&t));
+
+ if relies_only_on_inputs {
+ input_parameters.extend(
+ projection.ty.walk().filter_map(to_opt_param_ty));
+ }
+ }
+
+ if input_parameters.len() == num_inputs {
+ break;
+ }
+ }
+
+ for (index, ty_param) in ast_generics.ty_params.iter().enumerate() {
+ let param_ty = ty::ParamTy { space: TypeSpace,
+ idx: index as u32,
+ name: ty_param.ident.name };
+ if !input_parameters.contains(¶m_ty) {
+ if ty::has_attr(tcx, impl_def_id, "old_impl_check") {
+ tcx.sess.span_warn(
+ ty_param.span,
+ format!("the type parameter `{}` is not constrained by the \
+ impl trait, self type, or predicates",
+ param_ty.user_string(tcx)).as_slice());
+ } else {
+ tcx.sess.span_err(
+ ty_param.span,
+ format!("the type parameter `{}` is not constrained by the \
+ impl trait, self type, or predicates",
+ param_ty.user_string(tcx)).as_slice());
+ tcx.sess.span_help(
+ ty_param.span,
+ format!("you can temporarily opt out of this rule by placing \
+ the `#[old_impl_check]` attribute on the impl").as_slice());
+ }
+ }
+ }
+
+ fn to_opt_param_ty<'tcx>(ty: Ty<'tcx>) -> Option<ty::ParamTy> {
+ match ty.sty {
+ ty::ty_param(ref d) => Some(d.clone()),
+ _ => None,
+ }
+ }
+}
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(default_type_params, globs, macro_rules, phase, quote)]
+#![feature(quote)]
#![feature(slicing_syntax, unsafe_destructor)]
#![feature(rustc_diagnostic_macros)]
-#![feature(unboxed_closures)]
#![allow(non_camel_case_types)]
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate syntax;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate syntax;
+#[macro_use] extern crate log;
+#[macro_use] extern crate syntax;
extern crate arena;
extern crate rustc;
format!("{}: {}",
msg(),
ty::type_err_to_str(tcx,
- terr))[]);
+ terr)).index(&FullRange));
ty::note_and_explain_type_err(tcx, terr);
false
}
format!("main has a non-function type: found \
`{}`",
ppaux::ty_to_string(tcx,
- main_t))[]);
+ main_t)).index(&FullRange));
}
}
}
tcx.sess.span_bug(start_span,
format!("start has a non-function type: found \
`{}`",
- ppaux::ty_to_string(tcx, start_t))[]);
+ ppaux::ty_to_string(tcx, start_t)).index(&FullRange));
}
}
}
impl<'a> fmt::Show for VarianceTerm<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
- ConstantTerm(c1) => write!(f, "{}", c1),
- TransformTerm(v1, v2) => write!(f, "({} \u{00D7} {})", v1, v2),
+ ConstantTerm(c1) => write!(f, "{:?}", c1),
+ TransformTerm(v1, v2) => write!(f, "({:?} \u{00D7} {:?})", v1, v2),
InferredTerm(id) => write!(f, "[{}]", { let InferredIndex(i) = id; i })
}
}
assert!(newly_added);
debug!("add_inferred(item_id={}, \
- kind={}, \
+ kind={:?}, \
index={}, \
param_id={},
- inf_index={})",
+ inf_index={:?})",
item_id, kind, index, param_id, inf_index);
}
struct ConstraintContext<'a, 'tcx: 'a> {
terms_cx: TermsContext<'a, 'tcx>,
- // These are the def-id of the std::kinds::marker::InvariantType,
- // std::kinds::marker::InvariantLifetime, and so on. The arrays
+ // These are the def-id of the std::marker::InvariantType,
+ // std::marker::InvariantLifetime, and so on. The arrays
// are indexed by the `ParamKind` (type, lifetime, self). Note
// that there are no marker types for self, so the entries for
// self are always None.
None => {
self.tcx().sess.bug(format!(
"no inferred index entry for {}",
- self.tcx().map.node_to_string(param_id))[]);
+ self.tcx().map.node_to_string(param_id)).index(&FullRange));
}
}
}
fn add_constraint(&mut self,
InferredIndex(index): InferredIndex,
variance: VarianceTermPtr<'a>) {
- debug!("add_constraint(index={}, variance={})",
- index, variance.to_string());
+ debug!("add_constraint(index={}, variance={:?})",
+ index, variance);
self.constraints.push(Constraint { inferred: InferredIndex(index),
variance: variance });
}
self.tcx().sess.bug(
format!("unexpected type encountered in \
variance inference: {}",
- ty.repr(self.tcx()))[]);
+ ty.repr(self.tcx())).index(&FullRange));
}
}
}
region_param_defs: &[ty::RegionParameterDef],
substs: &subst::Substs<'tcx>,
variance: VarianceTermPtr<'a>) {
- debug!("add_constraints_from_substs(def_id={})", def_id);
+ debug!("add_constraints_from_substs(def_id={:?})", def_id);
for p in type_param_defs.iter() {
let variance_decl =
.sess
.bug(format!("unexpected region encountered in variance \
inference: {}",
- region.repr(self.tcx()))[]);
+ region.repr(self.tcx())).index(&FullRange));
}
}
}
let new_value = glb(variance, old_value);
if old_value != new_value {
debug!("Updating inferred {} (node {}) \
- from {} to {} due to {}",
+ from {:?} to {:?} due to {:?}",
inferred,
self.terms_cx
.inferred_infos[inferred]
.param_id,
old_value,
new_value,
- term.to_string());
+ term);
self.solutions[inferred] = new_value;
changed = true;
inferred_infos[index].item_id == item_id {
let info = &inferred_infos[index];
let variance = solutions[index];
- debug!("Index {} Info {} / {} / {} Variance {}",
+ debug!("Index {} Info {} / {:?} / {:?} Variance {:?}",
index, info.index, info.kind, info.space, variance);
match info.kind {
TypeParam => {
// attribute and report an error with various results if found.
if ty::has_attr(tcx, item_def_id, "rustc_variance") {
let found = item_variances.repr(tcx);
- tcx.sess.span_err(tcx.map.span(item_id), found[]);
+ tcx.sess.span_err(tcx.map.span(item_id), found.index(&FullRange));
}
let newly_added = tcx.item_variance_map.borrow_mut()
use syntax::print::pprust;
let expr = const_eval::lookup_const_by_id(tcx, did).unwrap_or_else(|| {
- panic!("expected lookup_const_by_id to succeed for {}", did);
+ panic!("expected lookup_const_by_id to succeed for {:?}", did);
});
- debug!("converting constant expr {} to snippet", expr);
+ debug!("converting constant expr {:?} to snippet", expr);
let sn = pprust::expr_to_string(expr);
debug!("got snippet {}", sn);
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub enum Attribute {
Word(String),
List(String, Vec<Attribute> ),
fn meta_item_list(&self) -> Option<&[P<ast::MetaItem>]> { None }
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct TyParam {
pub name: String,
pub did: ast::DefId,
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub enum TyParamBound {
RegionBound(Lifetime),
TraitBound(PolyTrait, ast::TraitBoundModifier)
cx.external_paths.borrow_mut().as_mut().unwrap().insert(self.def_id,
(fqn, TypeTrait));
- debug!("ty::TraitRef\n substs.types(TypeSpace): {}\n",
+ debug!("ty::TraitRef\n substs.types(TypeSpace): {:?}\n",
self.substs.types.get_slice(ParamSpace::TypeSpace));
// collect any late bound regions
for &ty_s in ts.iter() {
if let sty::ty_rptr(ref reg, _) = ty_s.sty {
if let &Region::ReLateBound(_, _) = *reg {
- debug!(" hit an ReLateBound {}", reg);
+ debug!(" hit an ReLateBound {:?}", reg);
if let Some(lt) = reg.clean(cx) {
late_bounds.push(lt)
}
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct Lifetime(String);
impl Lifetime {
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub enum WherePredicate {
BoundPredicate { ty: Type, bounds: Vec<TyParamBound> },
RegionPredicate { lifetime: Lifetime, bounds: Vec<Lifetime>},
}
// maybe use a Generic enum and use ~[Generic]?
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct Generics {
pub lifetimes: Vec<Lifetime>,
pub type_params: Vec<TyParam>,
let all_inputs = &self.pe_fn_decl().inputs;
let inputs = match self.pe_explicit_self().node {
ast::SelfStatic => all_inputs.as_slice(),
- _ => all_inputs[1..]
+ _ => all_inputs.index(&(1..))
};
let decl = FnDecl {
inputs: Arguments {
fn clean(&self, cx: &DocContext) -> Item {
let inputs = match self.explicit_self.node {
ast::SelfStatic => self.decl.inputs.as_slice(),
- _ => self.decl.inputs[1..]
+ _ => self.decl.inputs.index(&(1..))
};
let decl = FnDecl {
inputs: Arguments {
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct ClosureDecl {
pub lifetimes: Vec<Lifetime>,
pub decl: FnDecl,
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct FnDecl {
pub inputs: Arguments,
pub output: FunctionRetTy,
pub attrs: Vec<Attribute>,
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct Arguments {
pub values: Vec<Argument>,
}
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct Argument {
pub type_: Type,
pub name: String,
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub enum FunctionRetTy {
Return(Type),
NoReturn
self.fty.sig.clone()),
s => {
let sig = ty::Binder(ty::FnSig {
- inputs: self.fty.sig.0.inputs[1..].to_vec(),
+ inputs: self.fty.sig.0.inputs.index(&(1..)).to_vec(),
..self.fty.sig.0.clone()
});
let s = match s {
}
/// A trait reference, which may have higher ranked lifetimes.
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct PolyTrait {
pub trait_: Type,
pub lifetimes: Vec<Lifetime>
/// A representation of a Type suitable for hyperlinking purposes. Ideally one can get the original
/// type out of the AST/ty::ctxt given one of these, if more information is needed. Most importantly
/// it does not preserve mutability or boxes.
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub enum Type {
/// structs/enums/traits (anything that'd be an ast::TyPath)
ResolvedPath {
PolyTraitRef(Vec<TyParamBound>),
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Copy)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Copy, Show)]
pub enum PrimitiveType {
- Int, I8, I16, I32, I64,
- Uint, U8, U16, U32, U64,
+ Isize, I8, I16, I32, I64,
+ Usize, U8, U16, U32, U64,
F32, F64,
Char,
Bool,
impl PrimitiveType {
fn from_str(s: &str) -> Option<PrimitiveType> {
match s.as_slice() {
- "int" => Some(Int),
+ "isize" | "int" => Some(Isize),
"i8" => Some(I8),
"i16" => Some(I16),
"i32" => Some(I32),
"i64" => Some(I64),
- "uint" => Some(Uint),
+ "usize" | "uint" => Some(Usize),
"u8" => Some(U8),
"u16" => Some(U16),
"u32" => Some(U32),
pub fn to_string(&self) -> &'static str {
match *self {
- Int => "int",
+ Isize => "isize",
I8 => "i8",
I16 => "i16",
I32 => "i32",
I64 => "i64",
- Uint => "uint",
+ Usize => "usize",
U8 => "u8",
U16 => "u16",
U32 => "u32",
Infer
},
TyTypeof(..) => {
- panic!("Unimplemented type {}", self.node)
+ panic!("Unimplemented type {:?}", self.node)
},
}
}
match self.sty {
ty::ty_bool => Primitive(Bool),
ty::ty_char => Primitive(Char),
- ty::ty_int(ast::TyI) => Primitive(Int),
+ ty::ty_int(ast::TyIs) => Primitive(Isize),
ty::ty_int(ast::TyI8) => Primitive(I8),
ty::ty_int(ast::TyI16) => Primitive(I16),
ty::ty_int(ast::TyI32) => Primitive(I32),
ty::ty_int(ast::TyI64) => Primitive(I64),
- ty::ty_uint(ast::TyU) => Primitive(Uint),
+ ty::ty_uint(ast::TyUs) => Primitive(Usize),
ty::ty_uint(ast::TyU8) => Primitive(U8),
ty::ty_uint(ast::TyU16) => Primitive(U16),
ty::ty_uint(ast::TyU32) => Primitive(U32),
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct Path {
pub global: bool,
pub segments: Vec<PathSegment>,
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub enum PathParameters {
AngleBracketed {
lifetimes: Vec<Lifetime>,
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct PathSegment {
pub name: String,
pub params: PathParameters
}
}
-#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
pub struct BareFunctionDecl {
pub unsafety: ast::Unsafety,
pub generics: Generics,
impl Clean<Item> for doctree::Static {
fn clean(&self, cx: &DocContext) -> Item {
- debug!("claning static {}: {}", self.name.clean(cx), self);
+ debug!("cleaning static {}: {:?}", self.name.clean(cx), self);
Item {
name: Some(self.name.clean(cx)),
attrs: self.attrs.clean(cx),
impl ToSource for syntax::codemap::Span {
fn to_src(&self, cx: &DocContext) -> String {
- debug!("converting span {} to snippet", self.clean(cx));
+ debug!("converting span {:?} to snippet", self.clean(cx));
let sn = match cx.sess().codemap().span_to_snippet(*self) {
Some(x) => x.to_string(),
None => "".to_string()
fn lit_to_string(lit: &ast::Lit) -> String {
match lit.node {
ast::LitStr(ref st, _) => st.get().to_string(),
- ast::LitBinary(ref data) => format!("{}", data),
+ ast::LitBinary(ref data) => format!("{:?}", data),
ast::LitByte(b) => {
let mut res = String::from_str("b'");
for c in (b as char).escape_default() {
fn name_from_pat(p: &ast::Pat) -> String {
use syntax::ast::*;
- debug!("Trying to get a name from pattern: {}", p);
+ debug!("Trying to get a name from pattern: {:?}", p);
match p.node {
PatWild(PatWildSingle) => "_".to_string(),
ast::TyStr => return Primitive(Str),
ast::TyBool => return Primitive(Bool),
ast::TyChar => return Primitive(Char),
- ast::TyInt(ast::TyI) => return Primitive(Int),
+ ast::TyInt(ast::TyIs) => return Primitive(Isize),
ast::TyInt(ast::TyI8) => return Primitive(I8),
ast::TyInt(ast::TyI16) => return Primitive(I16),
ast::TyInt(ast::TyI32) => return Primitive(I32),
ast::TyInt(ast::TyI64) => return Primitive(I64),
- ast::TyUint(ast::TyU) => return Primitive(Uint),
+ ast::TyUint(ast::TyUs) => return Primitive(Usize),
ast::TyUint(ast::TyU8) => return Primitive(U8),
ast::TyUint(ast::TyU16) => return Primitive(U16),
ast::TyUint(ast::TyU32) => return Primitive(U32),
inlined: RefCell::new(Some(HashSet::new())),
populated_crate_impls: RefCell::new(HashSet::new()),
};
- debug!("crate: {}", ctxt.krate);
+ debug!("crate: {:?}", ctxt.krate);
let analysis = CrateAnalysis {
exported_items: exported_items,
/// string when passed to a format string.
pub struct Escape<'a>(pub &'a str);
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Escape<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Escape<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
// Because the internet is always right, turns out there's not that many
// characters to escape: http://stackoverflow.com/questions/7381974
//! HTML formatting module
//!
-//! This module contains a large number of `fmt::Show` implementations for
+//! This module contains a large number of `fmt::String` implementations for
//! various types in `rustdoc::clean`. These implementations all currently
//! assume that HTML output is desired, although it may be possible to redesign
//! them in the future to instead emit any format desired.
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for TyParamBounds<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for TyParamBounds<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let &TyParamBounds(bounds) = self;
for (i, bound) in bounds.iter().enumerate() {
}
}
-impl fmt::Show for clean::Generics {
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
+impl fmt::Show for clean::Generic {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::Generics {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) }
try!(f.write_str("<"));
if i > 0 {
try!(f.write_str(", "))
}
- try!(f.write_str(tp.name[]));
+ try!(f.write_str(tp.name.as_slice()));
if tp.bounds.len() > 0 {
try!(write!(f, ": {}", TyParamBounds(tp.bounds.as_slice())));
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for WhereClause<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for WhereClause<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let &WhereClause(gens) = self;
if gens.where_predicates.len() == 0 {
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::Lifetime {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::Lifetime {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(f.write_str(self.get_ref()));
Ok(())
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::PolyTrait {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::PolyTrait {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.lifetimes.len() > 0 {
try!(f.write_str("for<"));
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::TyParamBound {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::TyParamBound {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::RegionBound(ref lt) => {
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::PathParameters {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::PathParameters {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::PathParameters::AngleBracketed { ref lifetimes, ref types } => {
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::PathSegment {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::PathSegment {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(f.write_str(self.name.as_slice()));
write!(f, "{}", self.params)
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::Path {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::Path {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.global {
try!(f.write_str("::"))
match rel_root {
Some(root) => {
let mut root = String::from_str(root.as_slice());
- for seg in path.segments[..amt].iter() {
+ for seg in path.segments.index(&(0..amt)).iter() {
if "super" == seg.name ||
"self" == seg.name {
try!(write!(w, "{}::", seg.name));
}
}
None => {
- for seg in path.segments[..amt].iter() {
+ for seg in path.segments.index(&(0..amt)).iter() {
try!(write!(w, "{}::", seg.name));
}
}
// This is a documented path, link to it!
Some((ref fqp, shortty)) if abs_root.is_some() => {
let mut url = String::from_str(abs_root.unwrap().as_slice());
- let to_link = fqp[..fqp.len() - 1];
+ let to_link = &fqp[..(fqp.len() - 1)];
for component in to_link.iter() {
url.push_str(component.as_slice());
url.push_str("/");
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::Type {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::Type {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::TyParamBinder(id) => {
- f.write_str(cache().typarams[ast_util::local_def(id)][])
+ f.write_str(cache().typarams[ast_util::local_def(id)].as_slice())
}
clean::Generic(ref name) => {
f.write_str(name.as_slice())
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::Arguments {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+
+impl fmt::String for clean::Arguments {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, input) in self.values.iter().enumerate() {
if i > 0 { try!(write!(f, ", ")); }
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::FunctionRetTy {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::FunctionRetTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::Return(clean::Tuple(ref tys)) if tys.is_empty() => Ok(()),
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::FnDecl {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::FnDecl {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output)
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Method<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Method<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Method(selfty, d) = *self;
let mut args = String::new();
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for VisSpace {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for VisSpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.get() {
Some(ast::Public) => write!(f, "pub "),
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for UnsafetySpace {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for UnsafetySpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.get() {
ast::Unsafety::Unsafe => write!(f, "unsafe "),
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::ViewPath {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::ViewPath {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
clean::SimpleImport(ref name, ref src) => {
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::ImportSource {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::ImportSource {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.did {
Some(did) => resolved_path(f, did, &self.path, true),
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for clean::ViewListIdent {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for clean::ViewListIdent {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.source {
Some(did) => {
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for MutableSpace {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for MutableSpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MutableSpace(clean::Immutable) => Ok(()),
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for RawMutableSpace {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for RawMutableSpace {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RawMutableSpace(clean::Immutable) => write!(f, "const "),
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Stability<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Stability<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Stability(stab) = *self;
match *stab {
Some(ref stability) => {
write!(f, "<a class='stability {lvl}' title='{reason}'>{lvl}</a>",
- lvl = stability.level.to_string(),
+ lvl = stability.level,
reason = stability.text)
}
None => Ok(())
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for ConciseStability<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for ConciseStability<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let ConciseStability(stab) = *self;
match *stab {
Some(ref stability) => {
write!(f, "<a class='stability {lvl}' title='{lvl}{colon}{reason}'></a>",
- lvl = stability.level.to_string(),
+ lvl = stability.level,
colon = if stability.text.len() > 0 { ": " } else { "" },
reason = stability.text)
}
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for ModuleSummary {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for ModuleSummary {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt_inner<'a>(f: &mut fmt::Formatter,
context: &mut Vec<&'a str>,
class,
id,
&mut out).unwrap();
- String::from_utf8_lossy(out[]).into_owned()
+ String::from_utf8_lossy(out.index(&FullRange)).into_owned()
}
/// Exhausts the `lexer` writing the output into `out`.
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl fmt::Show for ItemType {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for ItemType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.to_static_str().fmt(f)
}
pub keywords: &'a str
}
-pub fn render<T: fmt::Show, S: fmt::Show>(
+pub fn render<T: fmt::String, S: fmt::String>(
dst: &mut io::Writer, layout: &Layout, page: &Page, sidebar: &S, t: &T)
-> io::IoResult<()>
{
//! (bundled into the rust runtime). This module self-contains the C bindings
//! and necessary legwork to render markdown, and exposes all of the
//! functionality through a unit-struct, `Markdown`, which has an implementation
-//! of `fmt::Show`. Example usage:
+//! of `fmt::String`. Example usage:
//!
//! ```rust,ignore
//! use rustdoc::html::markdown::Markdown;
use html::escape::Escape;
use test;
-/// A unit struct which has the `fmt::Show` trait implemented. When
+/// A unit struct which has the `fmt::String` trait implemented. When
/// formatted, this struct will emit the HTML corresponding to the rendered
/// version of the contained markdown string.
pub struct Markdown<'a>(pub &'a str);
let text = slice::from_raw_buf(&(*orig_text).data,
(*orig_text).size as uint);
let origtext = str::from_utf8(text).unwrap();
- debug!("docblock: ==============\n{}\n=======", text);
+ debug!("docblock: ==============\n{:?}\n=======", text);
let rendered = if lang.is_null() {
false
} else {
TEST_IDX.with(|s| s.set(0));
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Markdown<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Markdown<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let Markdown(md) = *self;
// This is actually common enough to special-case
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for MarkdownWithToc<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for MarkdownWithToc<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let MarkdownWithToc(md) = *self;
render(fmt, md.as_slice(), true)
search_index.push(IndexItem {
ty: shortty(item),
name: item.name.clone().unwrap(),
- path: fqp[..fqp.len() - 1].connect("::"),
+ path: fqp[..(fqp.len() - 1)].connect("::"),
desc: shorter(item.doc_value()).to_string(),
parent: Some(did),
});
};
let mut mydst = dst.clone();
- for part in remote_path[..remote_path.len() - 1].iter() {
+ for part in remote_path[..(remote_path.len() - 1)].iter() {
mydst.push(part.as_slice());
try!(mkdir(&mydst));
}
if let clean::ImplItem(ref i) = item.inner {
match i.trait_ {
Some(clean::ResolvedPath{ did, .. }) => {
- let v = self.implementors.entry(&did).get().unwrap_or_else(
+ let v = self.implementors.entry(did).get().unwrap_or_else(
|vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
v.push(Implementor {
def_id: item.def_id,
clean::StructFieldItem(..) |
clean::VariantItem(..) => {
((Some(*self.parent_stack.last().unwrap()),
- Some(self.stack[..self.stack.len() - 1])),
+ Some(&self.stack[..(self.stack.len() - 1)])),
false)
}
clean::MethodItem(..) => {
let did = *last;
let path = match self.paths.get(&did) {
Some(&(_, ItemType::Trait)) =>
- Some(self.stack[..self.stack.len() - 1]),
+ Some(&self.stack[..(self.stack.len() - 1)]),
// The current stack not necessarily has correlation for
// where the type was defined. On the other hand,
// `paths` always has the right information if present.
Some(&(ref fqp, ItemType::Struct)) |
Some(&(ref fqp, ItemType::Enum)) =>
- Some(fqp[..fqp.len() - 1]),
+ Some(&fqp[..(fqp.len() - 1)]),
Some(..) => Some(self.stack.as_slice()),
None => None
};
};
if let Some(did) = did {
- let v = self.impls.entry(&did).get().unwrap_or_else(
+ let v = self.impls.entry(did).get().unwrap_or_else(
|vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
v.push(Impl {
impl_: i,
F: FnOnce(&mut Context) -> T,
{
if s.len() == 0 {
- panic!("Unexpected empty destination: {}", self.current);
+ panic!("Unexpected empty destination: {:?}", self.current);
}
let prev = self.dst.clone();
self.dst.push(s.as_slice());
.collect::<String>();
match cache().paths.get(&it.def_id) {
Some(&(ref names, _)) => {
- for name in names[..names.len() - 1].iter() {
+ for name in (&names[..(names.len() - 1)]).iter() {
url.push_str(name.as_slice());
url.push_str("/");
}
Some(ref s) => s.to_string(),
};
let short = short.to_string();
- let v = map.entry(&short).get().unwrap_or_else(
+ let v = map.entry(short).get().unwrap_or_else(
|vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
v.push(myname);
}
}
-
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Item<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Item<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
// Write the breadcrumb trail header for the top
try!(write!(fmt, "\n<h1 class='fqn'><span class='in-band'>"));
indices.sort_by(|&i1, &i2| cmp(&items[i1], &items[i2], i1, i2));
- debug!("{}", indices);
+ debug!("{:?}", indices);
let mut curty = None;
for &idx in indices.iter() {
let myitem = &items[idx];
}
struct Initializer<'a>(&'a str);
+
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Initializer<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Initializer<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Initializer(s) = *self;
if s.len() == 0 { return Ok(()); }
try!(assoc_type(w, item, typaram));
try!(write!(w, "</code></h4>\n"));
}
- _ => panic!("can't make docs for trait item with name {}", item.name)
+ _ => panic!("can't make docs for trait item with name {:?}", item.name)
}
match item.doc_value() {
Some(s) if dox => {
document(w, it)
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Sidebar<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Sidebar<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let cx = self.cx;
let it = self.item;
}
}
+//NOTE(stage0): remove impl after snapshot
+#[cfg(stage0)]
impl<'a> fmt::Show for Source<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a> fmt::String for Source<'a> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let Source(s) = *self;
let lines = s.lines().count();
t: &clean::Macro) -> fmt::Result {
try!(w.write_str(highlight::highlight(t.source.as_slice(),
Some("macro"),
- None)[]));
+ None).as_slice()));
document(w, it)
}
}
impl fmt::Show for Toc {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for Toc {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
try!(write!(fmt, "<ul>"));
for entry in self.entries.iter() {
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-
-#![allow(unknown_features)]
-#![feature(globs, macro_rules, phase, slicing_syntax)]
-#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
-#![feature(associated_types)]
+#![feature(slicing_syntax)]
extern crate arena;
extern crate getopts;
extern crate serialize;
extern crate syntax;
extern crate "test" as testing;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
+#[macro_use] extern crate log;
extern crate "serialize" as rustc_serialize; // used by deriving
// reexported from `clean` so it can be easily updated with the mod itself
pub use clean::SCHEMA_VERSION;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod externalfiles;
pub mod clean;
pub fn main() {
static STACK_SIZE: uint = 32000000; // 32MB
- let res = std::thread::Builder::new().stack_size(STACK_SIZE).spawn(move || {
+ let res = std::thread::Builder::new().stack_size(STACK_SIZE).scoped(move || {
main_args(std::os::args().as_slice())
}).join();
std::os::set_exit_status(res.map_err(|_| ()).unwrap());
}
};
let name = name.to_string();
- let locs = externs.entry(&name).get().unwrap_or_else(
+ let locs = externs.entry(name).get().unwrap_or_else(
|vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
locs.push(location.to_string());
}
let cr = Path::new(cratefile);
info!("starting to run rustc");
- let (mut krate, analysis) = std::thread::Thread::spawn(move |:| {
+ let (mut krate, analysis) = std::thread::Thread::scoped(move |:| {
let cr = cr;
core::run_core(paths, cfgs, externs, &cr, triple)
}).join().map_err(|_| "rustc failed").unwrap();
}
};
match json::from_reader(&mut input) {
- Err(s) => Err(s.to_string()),
+ Err(s) => Err(format!("{:?}", s)),
Ok(Json::Object(obj)) => {
let mut obj = obj;
// Make sure the schema is what we expect
let crate_json_str = format!("{}", json::as_json(&krate));
let crate_json = match json::from_str(crate_json_str.as_slice()) {
Ok(j) => j,
- Err(e) => panic!("Rust generated JSON is invalid: {}", e)
+ Err(e) => panic!("Rust generated JSON is invalid: {:?}", e)
};
json.insert("crate".to_string(), crate_json);
None => box io::stderr() as Box<Writer>,
};
io::util::copy(&mut p, &mut err).unwrap();
- }).detach();
+ });
let emitter = diagnostic::EmitterWriter::new(box w2, None);
// Compile the code
if should_fail && out.status.success() {
panic!("test executable succeeded when it should have failed");
} else if !should_fail && !out.status.success() {
- panic!("test executable failed:\n{}",
+ panic!("test executable failed:\n{:?}",
str::from_utf8(out.error.as_slice()));
}
}
pub fn visit_item(&mut self, item: &ast::Item,
renamed: Option<ast::Ident>, om: &mut Module) {
- debug!("Visiting item {}", item);
+ debug!("Visiting item {:?}", item);
let name = renamed.unwrap_or(item.ident);
match item.node {
ast::ItemMod(ref m) => {
}
fn detail(&self) -> Option<String> {
- Some(self.to_string())
+ Some(format!("{:?}", self))
}
}
}
}
+#[old_impl_check]
impl<
K: Encodable + Hash<X> + Eq,
V: Encodable,
}
}
+#[old_impl_check]
impl<
K: Decodable + Hash<S> + Eq,
V: Decodable,
}
}
+#[old_impl_check]
impl<
T: Encodable + Hash<X> + Eq,
X,
}
}
+#[old_impl_check]
impl<
T: Decodable + Hash<S> + Eq,
S,
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Implementations of serialization for structures found in libcollections
-
-use std::uint;
-use std::default::Default;
-use std::hash::{Hash, Hasher};
-
-use {Decodable, Encodable, Decoder, Encoder};
-use std::collections::{DList, RingBuf, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
-use collections::enum_set::{EnumSet, CLike};
-
-impl<
- E,
- S: Encoder<E>,
- T: Encodable<S, E>
-> Encodable<S, E> for DList<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- }
- Ok(())
- })
- }
-}
-
-impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for DList<T> {
- fn decode(d: &mut D) -> Result<DList<T>, E> {
- d.read_seq(|d, len| {
- let mut list = DList::new();
- for i in range(0u, len) {
- list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(list)
- })
- }
-}
-
-impl<
- E,
- S: Encoder<E>,
- T: Encodable<S, E>
-> Encodable<S, E> for RingBuf<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- }
- Ok(())
- })
- }
-}
-
-impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> {
- fn decode(d: &mut D) -> Result<RingBuf<T>, E> {
- d.read_seq(|d, len| {
- let mut deque: RingBuf<T> = RingBuf::new();
- for i in range(0u, len) {
- deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(deque)
- })
- }
-}
-
-impl<
- E,
- S: Encoder<E>,
- K: Encodable<S, E> + PartialEq + Ord,
- V: Encodable<S, E> + PartialEq
-> Encodable<S, E> for BTreeMap<K, V> {
- fn encode(&self, e: &mut S) -> Result<(), E> {
- e.emit_map(self.len(), |e| {
- let mut i = 0;
- for (key, val) in self.iter() {
- try!(e.emit_map_elt_key(i, |e| key.encode(e)));
- try!(e.emit_map_elt_val(i, |e| val.encode(e)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<
- E,
- D: Decoder<E>,
- K: Decodable<D, E> + PartialEq + Ord,
- V: Decodable<D, E> + PartialEq
-> Decodable<D, E> for BTreeMap<K, V> {
- fn decode(d: &mut D) -> Result<BTreeMap<K, V>, E> {
- d.read_map(|d, len| {
- let mut map = BTreeMap::new();
- for i in range(0u, len) {
- let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
- let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
- map.insert(key, val);
- }
- Ok(map)
- })
- }
-}
-
-impl<
- E,
- S: Encoder<E>,
- T: Encodable<S, E> + PartialEq + Ord
-> Encodable<S, E> for BTreeSet<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_seq(self.len(), |s| {
- let mut i = 0;
- for e in self.iter() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<
- E,
- D: Decoder<E>,
- T: Decodable<D, E> + PartialEq + Ord
-> Decodable<D, E> for BTreeSet<T> {
- fn decode(d: &mut D) -> Result<BTreeSet<T>, E> {
- d.read_seq(|d, len| {
- let mut set = BTreeSet::new();
- for i in range(0u, len) {
- set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(set)
- })
- }
-}
-
-impl<
- E,
- S: Encoder<E>,
- T: Encodable<S, E> + CLike
-> Encodable<S, E> for EnumSet<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- let mut bits = 0;
- for item in self.iter() {
- bits |= item.to_uint();
- }
- s.emit_uint(bits)
- }
-}
-
-impl<
- E,
- D: Decoder<E>,
- T: Decodable<D, E> + CLike
-> Decodable<D, E> for EnumSet<T> {
- fn decode(d: &mut D) -> Result<EnumSet<T>, E> {
- let bits = try!(d.read_uint());
- let mut set = EnumSet::new();
- for bit in range(0, uint::BITS) {
- if bits & (1 << bit) != 0 {
- set.insert(CLike::from_uint(1 << bit));
- }
- }
- Ok(set)
- }
-}
-
-impl<
- E,
- S: Encoder<E>,
- K: Encodable<S, E> + Hash<X> + Eq,
- V: Encodable<S, E>,
- X,
- H: Hasher<X>
-> Encodable<S, E> for HashMap<K, V, H> {
- fn encode(&self, e: &mut S) -> Result<(), E> {
- e.emit_map(self.len(), |e| {
- let mut i = 0;
- for (key, val) in self.iter() {
- try!(e.emit_map_elt_key(i, |e| key.encode(e)));
- try!(e.emit_map_elt_val(i, |e| val.encode(e)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<
- E,
- D: Decoder<E>,
- K: Decodable<D, E> + Hash<S> + Eq,
- V: Decodable<D, E>,
- S,
- H: Hasher<S> + Default
-> Decodable<D, E> for HashMap<K, V, H> {
- fn decode(d: &mut D) -> Result<HashMap<K, V, H>, E> {
- d.read_map(|d, len| {
- let hasher = Default::default();
- let mut map = HashMap::with_capacity_and_hasher(len, hasher);
- for i in range(0u, len) {
- let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
- let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
- map.insert(key, val);
- }
- Ok(map)
- })
- }
-}
-
-impl<
- E,
- S: Encoder<E>,
- T: Encodable<S, E> + Hash<X> + Eq,
- X,
- H: Hasher<X>
-> Encodable<S, E> for HashSet<T, H> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_seq(self.len(), |s| {
- let mut i = 0;
- for e in self.iter() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)));
- i += 1;
- }
- Ok(())
- })
- }
-}
-
-impl<
- E,
- D: Decoder<E>,
- T: Decodable<D, E> + Hash<S> + Eq,
- S,
- H: Hasher<S> + Default
-> Decodable<D, E> for HashSet<T, H> {
- fn decode(d: &mut D) -> Result<HashSet<T, H>, E> {
- d.read_seq(|d, len| {
- let mut set = HashSet::with_capacity_and_hasher(len, Default::default());
- for i in range(0u, len) {
- set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(set)
- })
- }
-}
-
-impl<
- E,
- S: Encoder<E>,
- V: Encodable<S, E>
-> Encodable<S, E> for VecMap<V> {
- fn encode(&self, e: &mut S) -> Result<(), E> {
- e.emit_map(self.len(), |e| {
- for (i, (key, val)) in self.iter().enumerate() {
- try!(e.emit_map_elt_key(i, |e| key.encode(e)));
- try!(e.emit_map_elt_val(i, |e| val.encode(e)));
- }
- Ok(())
- })
- }
-}
-
-impl<
- E,
- D: Decoder<E>,
- V: Decodable<D, E>
-> Decodable<D, E> for VecMap<V> {
- fn decode(d: &mut D) -> Result<VecMap<V>, E> {
- d.read_map(|d, len| {
- let mut map = VecMap::new();
- for i in range(0u, len) {
- let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
- let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
- map.insert(key, val);
- }
- Ok(map)
- })
- }
-}
}
fn detail(&self) -> Option<String> {
- Some(self.to_string())
+ Some(format!("{:?}", self))
}
}
/// let hello_str = "Hello, World".as_bytes().to_hex();
/// println!("{}", hello_str);
/// let bytes = hello_str.as_slice().from_hex().unwrap();
- /// println!("{}", bytes);
+ /// println!("{:?}", bytes);
/// let result_str = String::from_utf8(bytes).unwrap();
/// println!("{}", result_str);
/// }
//! ```
use self::JsonEvent::*;
-use self::StackElement::*;
use self::ErrorCode::*;
use self::ParserError::*;
use self::DecoderError::*;
use std::num::FpCategory as Fp;
use std::str::FromStr;
use std::string;
-use std::ops;
+use std::ops::Index;
use unicode::str as unicode_str;
use unicode::str::Utf16Item;
use Encodable;
/// Represents a json value
-#[derive(Clone, PartialEq, PartialOrd)]
+#[derive(Clone, PartialEq, PartialOrd, Show)]
pub enum Json {
I64(i64),
U64(u64),
impl std::error::Error for DecoderError {
fn description(&self) -> &str { "decoder error" }
- fn detail(&self) -> Option<std::string::String> { Some(self.to_string()) }
+ fn detail(&self) -> Option<std::string::String> { Some(format!("{:?}", self)) }
}
pub type EncodeResult = fmt::Result;
};
if start < i {
- try!(wr.write_str(v[start..i]));
+ try!(wr.write_str(v.index(&(start..i))));
}
try!(wr.write_str(escaped));
}
if start != v.len() {
- try!(wr.write_str(v[start..]));
+ try!(wr.write_str(v.index(&(start..))));
}
wr.write_str("\"")
fn escape_char(writer: &mut fmt::Writer, v: char) -> fmt::Result {
let mut buf = [0; 4];
let n = v.encode_utf8(&mut buf).unwrap();
- let buf = unsafe { str::from_utf8_unchecked(buf[0..n]) };
+ let buf = unsafe { str::from_utf8_unchecked(buf.index(&(0..n))) };
escape_str(writer, buf)
}
}
if n > 0 {
- wr.write_str(BUF[..n])
+ wr.write_str(BUF.index(&(0..n)))
} else {
Ok(())
}
let mut check_encoder = Encoder::new(&mut buf);
try!(f(transmute(&mut check_encoder)));
}
- let out = str::from_utf8(buf[]).unwrap();
+ let out = str::from_utf8(buf.index(&FullRange)).unwrap();
let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
if needs_wrapping { try!(write!(self.writer, "\"")); }
try!(f(self));
let mut check_encoder = PrettyEncoder::new(&mut buf);
try!(f(transmute(&mut check_encoder)));
}
- let out = str::from_utf8(buf[]).unwrap();
+ let out = str::from_utf8(buf.index(&FullRange)).unwrap();
let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
if needs_wrapping { try!(write!(self.writer, "\"")); }
try!(f(self));
/// Returns None otherwise.
pub fn as_string<'a>(&'a self) -> Option<&'a str> {
match *self {
- Json::String(ref s) => Some(s[]),
+ Json::String(ref s) => Some(s.index(&FullRange)),
_ => None
}
}
}
}
-impl<'a> ops::Index<&'a str> for Json {
+impl<'a> Index<&'a str> for Json {
type Output = Json;
fn index(&self, idx: & &str) -> &Json {
}
}
-impl ops::Index<uint> for Json {
+impl Index<uint> for Json {
type Output = Json;
fn index<'a>(&'a self, idx: &uint) -> &'a Json {
}
/// StackElements compose a Stack.
-/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
+/// For example, StackElement::Key("foo"), StackElement::Key("bar"),
+/// StackElement::Index(3) and StackElement::Key("x") are the
/// StackElements compositing the stack that represents foo.bar[3].x
#[derive(PartialEq, Clone, Show)]
pub enum StackElement<'l> {
/// at the top.
pub fn get<'l>(&'l self, idx: uint) -> StackElement<'l> {
match self.stack[idx] {
- InternalIndex(i) => Index(i),
+ InternalIndex(i) => StackElement::Index(i),
InternalKey(start, size) => {
- Key(str::from_utf8(
- self.str_buffer[start as uint .. start as uint + size as uint]).unwrap())
+ StackElement::Key(str::from_utf8(
+ self.str_buffer.index(&((start as uint) .. (start as uint + size as uint))))
+ .unwrap())
}
}
}
pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
return match self.stack.last() {
None => None,
- Some(&InternalIndex(i)) => Some(Index(i)),
+ Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
Some(&InternalKey(start, size)) => {
- Some(Key(str::from_utf8(
- self.str_buffer[start as uint .. (start+size) as uint]
+ Some(StackElement::Key(str::from_utf8(
+ self.str_buffer.index(&((start as uint) .. (start+size) as uint))
).unwrap()))
}
}
}
- // Used by Parser to insert Key elements at the top of the stack.
+ // Used by Parser to insert StackElement::Key elements at the top of the stack.
fn push_key(&mut self, key: string::String) {
self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
for c in key.as_bytes().iter() {
}
}
- // Used by Parser to insert Index elements at the top of the stack.
+ // Used by Parser to insert StackElement::Index elements at the top of the stack.
fn push_index(&mut self, index: u32) {
self.stack.push(InternalIndex(index));
}
match self.token {
None => {}
Some(Error(e)) => { return Err(e); }
- ref tok => { panic!("unexpected token {}", tok.clone()); }
+ ref tok => { panic!("unexpected token {:?}", tok.clone()); }
}
result
}
_ => {}
}
let key = match self.parser.stack().top() {
- Some(Key(k)) => { k.to_string() }
+ Some(StackElement::Key(k)) => { k.to_string() }
_ => { panic!("invalid state"); }
};
match self.build_value() {
return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
}
};
- let idx = match names.iter().position(|n| *n == name[]) {
+ let idx = match names.iter().position(|n| *n == name.index(&FullRange)) {
Some(idx) => idx,
None => return Err(UnknownVariantError(name))
};
}
}
-impl fmt::Show for Json {
+impl fmt::String for Json {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
}
}
-impl<'a> fmt::Show for PrettyJson<'a> {
+impl<'a> fmt::String for PrettyJson<'a> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
}
}
+#[cfg(stage0)]
+//NOTE(stage0): remove impl after snapshot
impl<'a, T: Encodable> fmt::Show for AsJson<'a, T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a, T: Encodable> fmt::String for AsJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
}
}
-impl<'a, T: Encodable> fmt::Show for AsPrettyJson<'a, T> {
+impl<'a, T: Encodable> fmt::String for AsPrettyJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
use super::ParserError::*;
use super::DecoderError::*;
use super::JsonEvent::*;
- use super::StackElement::*;
use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser,
StackElement, Stack, Decoder};
- use std::{i64, u64, f32, f64};
+ use std::{i64, u64, f32, f64, io};
use std::collections::BTreeMap;
use std::num::Float;
+ use std::ops::Index;
use std::string;
#[derive(RustcDecodable, Eq, PartialEq, Show)]
assert_eq!(v, i64::MAX);
let res: DecodeResult<i64> = super::decode("765.25252");
- assert_eq!(res, Err(ExpectedError("Integer".to_string(), "765.25252".to_string())));
+ assert_eq!(res, Err(ExpectedError("Integer".to_string(),
+ "765.25252".to_string())));
}
#[test]
Ok(json) => Decodable::decode(&mut Decoder::new(json))
};
match res {
- Ok(_) => panic!("`{}` parsed & decoded ok, expecting error `{}`",
+ Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
to_parse, expected),
- Err(ParseError(e)) => panic!("`{}` is not valid json: {}",
+ Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}",
to_parse, e),
Err(e) => {
assert_eq!(e, expected);
hm.insert(1, true);
let mut mem_buf = Vec::new();
write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
- let json_str = from_utf8(mem_buf[]).unwrap();
+ let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap();
match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
_ => {} // it parsed and we are good to go
}
}
hm.insert(1, true);
let mut mem_buf = Vec::new();
write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
- let json_str = from_utf8(mem_buf[]).unwrap();
+ let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap();
match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
_ => {} // it parsed and we are good to go
}
}
write!(&mut writer, "{}",
super::as_pretty_json(&json).indent(i)).unwrap();
- let printed = from_utf8(writer[]).unwrap();
+ let printed = from_utf8(writer.index(&FullRange)).unwrap();
// Check for indents at each line
let lines: Vec<&str> = printed.lines().collect();
use Decodable;
let json_str = "{\"1\":true}";
let json_obj = match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
Ok(o) => o
};
let mut decoder = Decoder::new(json_obj);
use Decodable;
let json_str = "{\"a\":true}";
let json_obj = match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
+ Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
Ok(o) => o
};
let mut decoder = Decoder::new(json_obj);
};
let (ref expected_evt, ref expected_stack) = expected[i];
if !parser.stack().is_equal_to(expected_stack.as_slice()) {
- panic!("Parser stack is not equal to {}", expected_stack);
+ panic!("Parser stack is not equal to {:?}", expected_stack);
}
assert_eq!(&evt, expected_evt);
i+=1;
r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
vec![
(ObjectStart, vec![]),
- (StringValue("bar".to_string()), vec![Key("foo")]),
- (ArrayStart, vec![Key("array")]),
- (U64Value(0), vec![Key("array"), Index(0)]),
- (U64Value(1), vec![Key("array"), Index(1)]),
- (U64Value(2), vec![Key("array"), Index(2)]),
- (U64Value(3), vec![Key("array"), Index(3)]),
- (U64Value(4), vec![Key("array"), Index(4)]),
- (U64Value(5), vec![Key("array"), Index(5)]),
- (ArrayEnd, vec![Key("array")]),
- (ArrayStart, vec![Key("idents")]),
- (NullValue, vec![Key("idents"), Index(0)]),
- (BooleanValue(true), vec![Key("idents"), Index(1)]),
- (BooleanValue(false), vec![Key("idents"), Index(2)]),
- (ArrayEnd, vec![Key("idents")]),
+ (StringValue("bar".to_string()), vec![StackElement::Key("foo")]),
+ (ArrayStart, vec![StackElement::Key("array")]),
+ (U64Value(0), vec![StackElement::Key("array"), StackElement::Index(0)]),
+ (U64Value(1), vec![StackElement::Key("array"), StackElement::Index(1)]),
+ (U64Value(2), vec![StackElement::Key("array"), StackElement::Index(2)]),
+ (U64Value(3), vec![StackElement::Key("array"), StackElement::Index(3)]),
+ (U64Value(4), vec![StackElement::Key("array"), StackElement::Index(4)]),
+ (U64Value(5), vec![StackElement::Key("array"), StackElement::Index(5)]),
+ (ArrayEnd, vec![StackElement::Key("array")]),
+ (ArrayStart, vec![StackElement::Key("idents")]),
+ (NullValue, vec![StackElement::Key("idents"),
+ StackElement::Index(0)]),
+ (BooleanValue(true), vec![StackElement::Key("idents"),
+ StackElement::Index(1)]),
+ (BooleanValue(false), vec![StackElement::Key("idents"),
+ StackElement::Index(2)]),
+ (ArrayEnd, vec![StackElement::Key("idents")]),
(ObjectEnd, vec![]),
]
);
"{\"a\": 3}",
vec![
(ObjectStart, vec![]),
- (U64Value(3), vec![Key("a")]),
+ (U64Value(3), vec![StackElement::Key("a")]),
(ObjectEnd, vec![]),
]
);
"{ \"a\": null, \"b\" : true }",
vec![
(ObjectStart, vec![]),
- (NullValue, vec![Key("a")]),
- (BooleanValue(true), vec![Key("b")]),
+ (NullValue, vec![StackElement::Key("a")]),
+ (BooleanValue(true), vec![StackElement::Key("b")]),
(ObjectEnd, vec![]),
]
);
"{\"a\" : 1.0 ,\"b\": [ true ]}",
vec![
(ObjectStart, vec![]),
- (F64Value(1.0), vec![Key("a")]),
- (ArrayStart, vec![Key("b")]),
- (BooleanValue(true),vec![Key("b"), Index(0)]),
- (ArrayEnd, vec![Key("b")]),
+ (F64Value(1.0), vec![StackElement::Key("a")]),
+ (ArrayStart, vec![StackElement::Key("b")]),
+ (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]),
+ (ArrayEnd, vec![StackElement::Key("b")]),
(ObjectEnd, vec![]),
]
);
}"#,
vec![
(ObjectStart, vec![]),
- (F64Value(1.0), vec![Key("a")]),
- (ArrayStart, vec![Key("b")]),
- (BooleanValue(true), vec![Key("b"), Index(0)]),
- (StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]),
- (ObjectStart, vec![Key("b"), Index(2)]),
- (ObjectStart, vec![Key("b"), Index(2), Key("c")]),
- (NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]),
- (ObjectEnd, vec![Key("b"), Index(2), Key("c")]),
- (ObjectEnd, vec![Key("b"), Index(2)]),
- (ArrayEnd, vec![Key("b")]),
+ (F64Value(1.0), vec![StackElement::Key("a")]),
+ (ArrayStart, vec![StackElement::Key("b")]),
+ (BooleanValue(true), vec![StackElement::Key("b"),
+ StackElement::Index(0)]),
+ (StringValue("foo\nbar".to_string()), vec![StackElement::Key("b"),
+ StackElement::Index(1)]),
+ (ObjectStart, vec![StackElement::Key("b"),
+ StackElement::Index(2)]),
+ (ObjectStart, vec![StackElement::Key("b"),
+ StackElement::Index(2),
+ StackElement::Key("c")]),
+ (NullValue, vec![StackElement::Key("b"),
+ StackElement::Index(2),
+ StackElement::Key("c"),
+ StackElement::Key("d")]),
+ (ObjectEnd, vec![StackElement::Key("b"),
+ StackElement::Index(2),
+ StackElement::Key("c")]),
+ (ObjectEnd, vec![StackElement::Key("b"),
+ StackElement::Index(2)]),
+ (ArrayEnd, vec![StackElement::Key("b")]),
(ObjectEnd, vec![]),
]
);
"[true]",
vec![
(ArrayStart, vec![]),
- (BooleanValue(true), vec![Index(0)]),
+ (BooleanValue(true), vec![StackElement::Index(0)]),
(ArrayEnd, vec![]),
]
);
"[ false ]",
vec![
(ArrayStart, vec![]),
- (BooleanValue(false), vec![Index(0)]),
+ (BooleanValue(false), vec![StackElement::Index(0)]),
(ArrayEnd, vec![]),
]
);
"[null]",
vec![
(ArrayStart, vec![]),
- (NullValue, vec![Index(0)]),
+ (NullValue, vec![StackElement::Index(0)]),
(ArrayEnd, vec![]),
]
);
"[3, 1]",
vec![
(ArrayStart, vec![]),
- (U64Value(3), vec![Index(0)]),
- (U64Value(1), vec![Index(1)]),
+ (U64Value(3), vec![StackElement::Index(0)]),
+ (U64Value(1), vec![StackElement::Index(1)]),
(ArrayEnd, vec![]),
]
);
"\n[3, 2]\n",
vec![
(ArrayStart, vec![]),
- (U64Value(3), vec![Index(0)]),
- (U64Value(2), vec![Index(1)]),
+ (U64Value(3), vec![StackElement::Index(0)]),
+ (U64Value(2), vec![StackElement::Index(1)]),
(ArrayEnd, vec![]),
]
);
"[2, [4, 1]]",
vec![
(ArrayStart, vec![]),
- (U64Value(2), vec![Index(0)]),
- (ArrayStart, vec![Index(1)]),
- (U64Value(4), vec![Index(1), Index(0)]),
- (U64Value(1), vec![Index(1), Index(1)]),
- (ArrayEnd, vec![Index(1)]),
+ (U64Value(2), vec![StackElement::Index(0)]),
+ (ArrayStart, vec![StackElement::Index(1)]),
+ (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]),
+ (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]),
+ (ArrayEnd, vec![StackElement::Index(1)]),
(ArrayEnd, vec![]),
]
);
stack.bump_index();
assert!(stack.len() == 1);
- assert!(stack.is_equal_to(&[Index(1)]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1)]));
+ assert!(stack.is_equal_to(&[StackElement::Index(1)]));
+ assert!(stack.starts_with(&[StackElement::Index(1)]));
+ assert!(stack.ends_with(&[StackElement::Index(1)]));
assert!(stack.last_is_index());
- assert!(stack.get(0) == Index(1));
+ assert!(stack.get(0) == StackElement::Index(1));
stack.push_key("foo".to_string());
assert!(stack.len() == 2);
- assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1), Key("foo")]));
- assert!(stack.ends_with(&[Key("foo")]));
+ assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")]));
+ assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
+ assert!(stack.starts_with(&[StackElement::Index(1)]));
+ assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")]));
+ assert!(stack.ends_with(&[StackElement::Key("foo")]));
assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
+ assert!(stack.get(0) == StackElement::Index(1));
+ assert!(stack.get(1) == StackElement::Key("foo"));
stack.push_key("bar".to_string());
assert!(stack.len() == 3);
- assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")]));
- assert!(stack.ends_with(&[Key("bar")]));
- assert!(stack.ends_with(&[Key("foo"), Key("bar")]));
- assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")]));
+ assert!(stack.is_equal_to(&[StackElement::Index(1),
+ StackElement::Key("foo"),
+ StackElement::Key("bar")]));
+ assert!(stack.starts_with(&[StackElement::Index(1)]));
+ assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
+ assert!(stack.starts_with(&[StackElement::Index(1),
+ StackElement::Key("foo"),
+ StackElement::Key("bar")]));
+ assert!(stack.ends_with(&[StackElement::Key("bar")]));
+ assert!(stack.ends_with(&[StackElement::Key("foo"), StackElement::Key("bar")]));
+ assert!(stack.ends_with(&[StackElement::Index(1),
+ StackElement::Key("foo"),
+ StackElement::Key("bar")]));
assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
- assert!(stack.get(2) == Key("bar"));
+ assert!(stack.get(0) == StackElement::Index(1));
+ assert!(stack.get(1) == StackElement::Key("foo"));
+ assert!(stack.get(2) == StackElement::Key("bar"));
stack.pop();
assert!(stack.len() == 2);
- assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1), Key("foo")]));
- assert!(stack.ends_with(&[Key("foo")]));
+ assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")]));
+ assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
+ assert!(stack.starts_with(&[StackElement::Index(1)]));
+ assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")]));
+ assert!(stack.ends_with(&[StackElement::Key("foo")]));
assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
+ assert!(stack.get(0) == StackElement::Index(1));
+ assert!(stack.get(1) == StackElement::Key("foo"));
}
#[test]
+++ /dev/null
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Rust JSON serialization library
-// Copyright (c) 2011 Google Inc.
-
-#![forbid(non_camel_case_types)]
-#![allow(missing_docs)]
-
-//! JSON parsing and serialization
-//!
-//! # What is JSON?
-//!
-//! JSON (JavaScript Object Notation) is a way to write data in Javascript.
-//! Like XML, it allows to encode structured data in a text format that can be easily read by humans
-//! Its simple syntax and native compatibility with JavaScript have made it a widely used format.
-//!
-//! Data types that can be encoded are JavaScript types (see the `Json` enum for more details):
-//!
-//! * `Boolean`: equivalent to rust's `bool`
-//! * `Number`: equivalent to rust's `f64`
-//! * `String`: equivalent to rust's `String`
-//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the
-//! same array
-//! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
-//! * `Null`
-//!
-//! An object is a series of string keys mapping to values, in `"key": value` format.
-//! Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
-//! A simple JSON document encoding a person, his/her age, address and phone numbers could look like
-//!
-//! ```ignore
-//! {
-//! "FirstName": "John",
-//! "LastName": "Doe",
-//! "Age": 43,
-//! "Address": {
-//! "Street": "Downing Street 10",
-//! "City": "London",
-//! "Country": "Great Britain"
-//! },
-//! "PhoneNumbers": [
-//! "+44 1234567",
-//! "+44 2345678"
-//! ]
-//! }
-//! ```
-//!
-//! # Rust Type-based Encoding and Decoding
-//!
-//! Rust provides a mechanism for low boilerplate encoding & decoding of values to and from JSON via
-//! the serialization API.
-//! To be able to encode a piece of data, it must implement the `serialize::RustcEncodable` trait.
-//! To be able to decode a piece of data, it must implement the `serialize::RustcDecodable` trait.
-//! The Rust compiler provides an annotation to automatically generate the code for these traits:
-//! `#[derive(RustcDecodable, RustcEncodable)]`
-//!
-//! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode objects.
-//! The `ToJson` trait provides a `to_json` method to convert an object into a `json::Json` value.
-//! A `json::Json` value can be encoded as a string or buffer using the functions described above.
-//! You can also use the `json::Encoder` object, which implements the `Encoder` trait.
-//!
-//! When using `ToJson` the `RustcEncodable` trait implementation is not mandatory.
-//!
-//! # Examples of use
-//!
-//! ## Using Autoserialization
-//!
-//! Create a struct called `TestStruct` and serialize and deserialize it to and from JSON using the
-//! serialization API, using the derived serialization code.
-//!
-//! ```notrust
-//! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
-//! extern crate serialize;
-//! use serialize::json;
-//!
-//! // Automatically generate `Decodable` and `Encodable` trait implementations
-//! #[derive(RustcDecodable, RustcEncodable)]
-//! pub struct TestStruct {
-//! data_int: u8,
-//! data_str: String,
-//! data_vector: Vec<u8>,
-//! }
-//!
-//! fn main() {
-//! let object = TestStruct {
-//! data_int: 1,
-//! data_str: "homura".to_string(),
-//! data_vector: vec![2,3,4,5],
-//! };
-//!
-//! // Serialize using `json::encode`
-//! let encoded = json::encode(&object);
-//!
-//! // Deserialize using `json::decode`
-//! let decoded: TestStruct = json::decode(encoded.as_slice()).unwrap();
-//! }
-//! ```
-//!
-//! ## Using the `ToJson` trait
-//!
-//! The examples above use the `ToJson` trait to generate the JSON string, which is required
-//! for custom mappings.
-//!
-//! ### Simple example of `ToJson` usage
-//!
-//! ```notrust
-//! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
-//! extern crate serialize;
-//! use serialize::json::{mod, ToJson, Json};
-//!
-//! // A custom data structure
-//! struct ComplexNum {
-//! a: f64,
-//! b: f64,
-//! }
-//!
-//! // JSON value representation
-//! impl ToJson for ComplexNum {
-//! fn to_json(&self) -> Json {
-//! Json::String(format!("{}+{}i", self.a, self.b))
-//! }
-//! }
-//!
-//! // Only generate `RustcEncodable` trait implementation
-//! #[derive(Encodable)]
-//! pub struct ComplexNumRecord {
-//! uid: u8,
-//! dsc: String,
-//! val: Json,
-//! }
-//!
-//! fn main() {
-//! let num = ComplexNum { a: 0.0001, b: 12.539 };
-//! let data: String = json::encode(&ComplexNumRecord{
-//! uid: 1,
-//! dsc: "test".to_string(),
-//! val: num.to_json(),
-//! });
-//! println!("data: {}", data);
-//! // data: {"uid":1,"dsc":"test","val":"0.0001+12.539j"};
-//! }
-//! ```
-//!
-//! ### Verbose example of `ToJson` usage
-//!
-//! ```notrust
-//! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
-//! extern crate serialize;
-//! use std::collections::BTreeMap;
-//! use serialize::json::{mod, Json, ToJson};
-//!
-//! // Only generate `Decodable` trait implementation
-//! #[derive(Decodable)]
-//! pub struct TestStruct {
-//! data_int: u8,
-//! data_str: String,
-//! data_vector: Vec<u8>,
-//! }
-//!
-//! // Specify encoding method manually
-//! impl ToJson for TestStruct {
-//! fn to_json(&self) -> Json {
-//! let mut d = BTreeMap::new();
-//! // All standard types implement `to_json()`, so use it
-//! d.insert("data_int".to_string(), self.data_int.to_json());
-//! d.insert("data_str".to_string(), self.data_str.to_json());
-//! d.insert("data_vector".to_string(), self.data_vector.to_json());
-//! Json::Object(d)
-//! }
-//! }
-//!
-//! fn main() {
-//! // Serialize using `ToJson`
-//! let input_data = TestStruct {
-//! data_int: 1,
-//! data_str: "madoka".to_string(),
-//! data_vector: vec![2,3,4,5],
-//! };
-//! let json_obj: Json = input_data.to_json();
-//! let json_str: String = json_obj.to_string();
-//!
-//! // Deserialize like before
-//! let decoded: TestStruct = json::decode(json_str.as_slice()).unwrap();
-//! }
-//! ```
-
-use self::JsonEvent::*;
-use self::StackElement::*;
-use self::ErrorCode::*;
-use self::ParserError::*;
-use self::DecoderError::*;
-use self::ParserState::*;
-use self::InternalStackElement::*;
-
-use std;
-use std::collections::{HashMap, BTreeMap};
-use std::{char, f64, fmt, io, num, str};
-use std::mem::{swap, transmute};
-use std::num::{Float, Int};
-use std::num::FpCategory as Fp;
-use std::str::FromStr;
-use std::string;
-use std::ops;
-use unicode::str as unicode_str;
-use unicode::str::Utf16Item;
-
-use Encodable;
-
-/// Represents a json value
-#[derive(Clone, PartialEq, PartialOrd)]
-pub enum Json {
- I64(i64),
- U64(u64),
- F64(f64),
- String(string::String),
- Boolean(bool),
- Array(self::Array),
- Object(self::Object),
- Null,
-}
-
-pub type Array = Vec<Json>;
-pub type Object = BTreeMap<string::String, Json>;
-
-pub struct PrettyJson<'a> { inner: &'a Json }
-
-pub struct AsJson<'a, T: 'a> { inner: &'a T }
-pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<uint> }
-
-/// The errors that can arise while parsing a JSON stream.
-#[derive(Clone, Copy, PartialEq)]
-pub enum ErrorCode {
- InvalidSyntax,
- InvalidNumber,
- EOFWhileParsingObject,
- EOFWhileParsingArray,
- EOFWhileParsingValue,
- EOFWhileParsingString,
- KeyMustBeAString,
- ExpectedColon,
- TrailingCharacters,
- TrailingComma,
- InvalidEscape,
- InvalidUnicodeCodePoint,
- LoneLeadingSurrogateInHexEscape,
- UnexpectedEndOfHexEscape,
- UnrecognizedHex,
- NotFourDigit,
- NotUtf8,
-}
-
-#[derive(Clone, Copy, PartialEq, Show)]
-pub enum ParserError {
- /// msg, line, col
- SyntaxError(ErrorCode, uint, uint),
- IoError(io::IoErrorKind, &'static str),
-}
-
-// Builder and Parser have the same errors.
-pub type BuilderError = ParserError;
-
-#[derive(Clone, PartialEq, Show)]
-pub enum DecoderError {
- ParseError(ParserError),
- ExpectedError(string::String, string::String),
- MissingFieldError(string::String),
- UnknownVariantError(string::String),
- ApplicationError(string::String)
-}
-
-/// Returns a readable error string for a given error code.
-pub fn error_str(error: ErrorCode) -> &'static str {
- match error {
- InvalidSyntax => "invalid syntax",
- InvalidNumber => "invalid number",
- EOFWhileParsingObject => "EOF While parsing object",
- EOFWhileParsingArray => "EOF While parsing array",
- EOFWhileParsingValue => "EOF While parsing value",
- EOFWhileParsingString => "EOF While parsing string",
- KeyMustBeAString => "key must be a string",
- ExpectedColon => "expected `:`",
- TrailingCharacters => "trailing characters",
- TrailingComma => "trailing comma",
- InvalidEscape => "invalid escape",
- UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)",
- NotFourDigit => "invalid \\u{ esc}ape (not four digits)",
- NotUtf8 => "contents not utf-8",
- InvalidUnicodeCodePoint => "invalid Unicode code point",
- LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
- UnexpectedEndOfHexEscape => "unexpected end of hex escape",
- }
-}
-
-/// Shortcut function to decode a JSON `&str` into an object
-pub fn decode<T: ::Decodable<Decoder, DecoderError>>(s: &str) -> DecodeResult<T> {
- let json = match from_str(s) {
- Ok(x) => x,
- Err(e) => return Err(ParseError(e))
- };
-
- let mut decoder = Decoder::new(json);
- ::Decodable::decode(&mut decoder)
-}
-
-/// Shortcut function to encode a `T` into a JSON `String`
-pub fn encode<T>(object: &T) -> string::String
- where T: for<'a> Encodable<Encoder<'a>, fmt::Error>
-{
- let mut s = String::new();
- {
- let mut encoder = Encoder::new(&mut s);
- let _ = object.encode(&mut encoder);
- }
- s
-}
-
-impl fmt::Show for ErrorCode {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- error_str(*self).fmt(f)
- }
-}
-
-fn io_error_to_error(io: io::IoError) -> ParserError {
- IoError(io.kind, io.desc)
-}
-
-impl std::error::Error for DecoderError {
- fn description(&self) -> &str { "decoder error" }
- fn detail(&self) -> Option<std::string::String> { Some(self.to_string()) }
-}
-
-pub type EncodeResult = fmt::Result;
-pub type DecodeResult<T> = Result<T, DecoderError>;
-
-fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result {
- try!(wr.write_str("\""));
-
- let mut start = 0;
-
- for (i, byte) in v.bytes().enumerate() {
- let escaped = match byte {
- b'"' => "\\\"",
- b'\\' => "\\\\",
- b'\x00' => "\\u0000",
- b'\x01' => "\\u0001",
- b'\x02' => "\\u0002",
- b'\x03' => "\\u0003",
- b'\x04' => "\\u0004",
- b'\x05' => "\\u0005",
- b'\x06' => "\\u0006",
- b'\x07' => "\\u0007",
- b'\x08' => "\\b",
- b'\t' => "\\t",
- b'\n' => "\\n",
- b'\x0b' => "\\u000b",
- b'\x0c' => "\\f",
- b'\r' => "\\r",
- b'\x0e' => "\\u000e",
- b'\x0f' => "\\u000f",
- b'\x10' => "\\u0010",
- b'\x11' => "\\u0011",
- b'\x12' => "\\u0012",
- b'\x13' => "\\u0013",
- b'\x14' => "\\u0014",
- b'\x15' => "\\u0015",
- b'\x16' => "\\u0016",
- b'\x17' => "\\u0017",
- b'\x18' => "\\u0018",
- b'\x19' => "\\u0019",
- b'\x1a' => "\\u001a",
- b'\x1b' => "\\u001b",
- b'\x1c' => "\\u001c",
- b'\x1d' => "\\u001d",
- b'\x1e' => "\\u001e",
- b'\x1f' => "\\u001f",
- b'\x7f' => "\\u007f",
- _ => { continue; }
- };
-
- if start < i {
- try!(wr.write_str(v[start..i]));
- }
-
- try!(wr.write_str(escaped));
-
- start = i + 1;
- }
-
- if start != v.len() {
- try!(wr.write_str(v[start..]));
- }
-
- wr.write_str("\"")
-}
-
-fn escape_char(writer: &mut fmt::Writer, v: char) -> fmt::Result {
- let mut buf = [0; 4];
- let n = v.encode_utf8(&mut buf).unwrap();
- let buf = unsafe { str::from_utf8_unchecked(buf[0..n]) };
- escape_str(writer, buf)
-}
-
-fn spaces(wr: &mut fmt::Writer, mut n: uint) -> fmt::Result {
- const BUF: &'static str = " ";
-
- while n >= BUF.len() {
- try!(wr.write_str(BUF));
- n -= BUF.len();
- }
-
- if n > 0 {
- wr.write_str(BUF[..n])
- } else {
- Ok(())
- }
-}
-
-fn fmt_number_or_null(v: f64) -> string::String {
- match v.classify() {
- Fp::Nan | Fp::Infinite => string::String::from_str("null"),
- _ if v.fract() != 0f64 => f64::to_str_digits(v, 6u),
- _ => f64::to_str_digits(v, 6u) + ".0",
- }
-}
-
-/// A structure for implementing serialization to JSON.
-pub struct Encoder<'a> {
- writer: &'a mut (fmt::Writer+'a),
-}
-
-impl<'a> Encoder<'a> {
- /// Creates a new JSON encoder whose output will be written to the writer
- /// specified.
- pub fn new(writer: &'a mut fmt::Writer) -> Encoder<'a> {
- Encoder { writer: writer }
- }
-}
-
-impl<'a> ::Encoder<fmt::Error> for Encoder<'a> {
- fn emit_nil(&mut self) -> EncodeResult { write!(self.writer, "null") }
-
- fn emit_uint(&mut self, v: uint) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u64(&mut self, v: u64) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u32(&mut self, v: u32) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u16(&mut self, v: u16) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u8(&mut self, v: u8) -> EncodeResult { write!(self.writer, "{}", v) }
-
- fn emit_int(&mut self, v: int) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i64(&mut self, v: i64) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i32(&mut self, v: i32) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i16(&mut self, v: i16) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i8(&mut self, v: i8) -> EncodeResult { write!(self.writer, "{}", v) }
-
- fn emit_bool(&mut self, v: bool) -> EncodeResult {
- if v {
- write!(self.writer, "true")
- } else {
- write!(self.writer, "false")
- }
- }
-
- fn emit_f64(&mut self, v: f64) -> EncodeResult {
- write!(self.writer, "{}", fmt_number_or_null(v))
- }
- fn emit_f32(&mut self, v: f32) -> EncodeResult {
- self.emit_f64(v as f64)
- }
-
- fn emit_char(&mut self, v: char) -> EncodeResult {
- escape_char(self.writer, v)
- }
- fn emit_str(&mut self, v: &str) -> EncodeResult {
- escape_str(self.writer, v)
- }
-
- fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- f(self)
- }
-
- fn emit_enum_variant<F>(&mut self,
- name: &str,
- _id: uint,
- cnt: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- // enums are encoded as strings or objects
- // Bunny => "Bunny"
- // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
- if cnt == 0 {
- escape_str(self.writer, name)
- } else {
- try!(write!(self.writer, "{{\"variant\":"));
- try!(escape_str(self.writer, name));
- try!(write!(self.writer, ",\"fields\":["));
- try!(f(self));
- write!(self.writer, "]}}")
- }
- }
-
- fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- if idx != 0 {
- try!(write!(self.writer, ","));
- }
- f(self)
- }
-
- fn emit_enum_struct_variant<F>(&mut self,
- name: &str,
- id: uint,
- cnt: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- self.emit_enum_variant(name, id, cnt, f)
- }
-
- fn emit_enum_struct_variant_field<F>(&mut self,
- _: &str,
- idx: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- self.emit_enum_variant_arg(idx, f)
- }
-
- fn emit_struct<F>(&mut self, _: &str, _: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- try!(write!(self.writer, "{{"));
- try!(f(self));
- write!(self.writer, "}}")
- }
-
- fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- if idx != 0 { try!(write!(self.writer, ",")); }
- try!(escape_str(self.writer, name));
- try!(write!(self.writer, ":"));
- f(self)
- }
-
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- self.emit_seq(len, f)
- }
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_tuple_struct<F>(&mut self, _name: &str, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- self.emit_seq(len, f)
- }
- fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_option<F>(&mut self, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- f(self)
- }
- fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() }
- fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- f(self)
- }
-
- fn emit_seq<F>(&mut self, _len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- try!(write!(self.writer, "["));
- try!(f(self));
- write!(self.writer, "]")
- }
-
- fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- if idx != 0 {
- try!(write!(self.writer, ","));
- }
- f(self)
- }
-
- fn emit_map<F>(&mut self, _len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- try!(write!(self.writer, "{{"));
- try!(f(self));
- write!(self.writer, "}}")
- }
-
- fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EncodeResult where
- F: FnMut(&mut Encoder<'a>) -> EncodeResult,
- {
- if idx != 0 { try!(write!(self.writer, ",")) }
- // ref #12967, make sure to wrap a key in double quotes,
- // in the event that its of a type that omits them (eg numbers)
- let mut buf = Vec::new();
- // FIXME(14302) remove the transmute and unsafe block.
- unsafe {
- let mut check_encoder = Encoder::new(&mut buf);
- try!(f(transmute(&mut check_encoder)));
- }
- let out = str::from_utf8(buf[]).unwrap();
- let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
- if needs_wrapping { try!(write!(self.writer, "\"")); }
- try!(f(self));
- if needs_wrapping { try!(write!(self.writer, "\"")); }
- Ok(())
- }
-
- fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
- {
- try!(write!(self.writer, ":"));
- f(self)
- }
-}
-
-/// Another encoder for JSON, but prints out human-readable JSON instead of
-/// compact data
-pub struct PrettyEncoder<'a> {
- writer: &'a mut (fmt::Writer+'a),
- curr_indent: uint,
- indent: uint,
-}
-
-impl<'a> PrettyEncoder<'a> {
- /// Creates a new encoder whose output will be written to the specified writer
- pub fn new(writer: &'a mut fmt::Writer) -> PrettyEncoder<'a> {
- PrettyEncoder { writer: writer, curr_indent: 0, indent: 2, }
- }
-
- /// Set the number of spaces to indent for each level.
- /// This is safe to set during encoding.
- pub fn set_indent(&mut self, indent: uint) {
- // self.indent very well could be 0 so we need to use checked division.
- let level = self.curr_indent.checked_div(self.indent).unwrap_or(0);
- self.indent = indent;
- self.curr_indent = level * self.indent;
- }
-}
-
-impl<'a> ::Encoder<fmt::Error> for PrettyEncoder<'a> {
- fn emit_nil(&mut self) -> EncodeResult { write!(self.writer, "null") }
-
- fn emit_uint(&mut self, v: uint) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u64(&mut self, v: u64) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u32(&mut self, v: u32) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u16(&mut self, v: u16) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_u8(&mut self, v: u8) -> EncodeResult { write!(self.writer, "{}", v) }
-
- fn emit_int(&mut self, v: int) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i64(&mut self, v: i64) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i32(&mut self, v: i32) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i16(&mut self, v: i16) -> EncodeResult { write!(self.writer, "{}", v) }
- fn emit_i8(&mut self, v: i8) -> EncodeResult { write!(self.writer, "{}", v) }
-
- fn emit_bool(&mut self, v: bool) -> EncodeResult {
- if v {
- write!(self.writer, "true")
- } else {
- write!(self.writer, "false")
- }
- }
-
- fn emit_f64(&mut self, v: f64) -> EncodeResult {
- write!(self.writer, "{}", fmt_number_or_null(v))
- }
- fn emit_f32(&mut self, v: f32) -> EncodeResult {
- self.emit_f64(v as f64)
- }
-
- fn emit_char(&mut self, v: char) -> EncodeResult {
- escape_char(self.writer, v)
- }
- fn emit_str(&mut self, v: &str) -> EncodeResult {
- escape_str(self.writer, v)
- }
-
- fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- f(self)
- }
-
- fn emit_enum_variant<F>(&mut self,
- name: &str,
- _id: uint,
- cnt: uint,
- f: F)
- -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if cnt == 0 {
- escape_str(self.writer, name)
- } else {
- try!(write!(self.writer, "{{\n"));
- self.curr_indent += self.indent;
- try!(spaces(self.writer, self.curr_indent));
- try!(write!(self.writer, "\"variant\": "));
- try!(escape_str(self.writer, name));
- try!(write!(self.writer, ",\n"));
- try!(spaces(self.writer, self.curr_indent));
- try!(write!(self.writer, "\"fields\": [\n"));
- self.curr_indent += self.indent;
- try!(f(self));
- self.curr_indent -= self.indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, self.curr_indent));
- self.curr_indent -= self.indent;
- try!(write!(self.writer, "]\n"));
- try!(spaces(self.writer, self.curr_indent));
- write!(self.writer, "}}")
- }
- }
-
- fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if idx != 0 {
- try!(write!(self.writer, ",\n"));
- }
- try!(spaces(self.writer, self.curr_indent));
- f(self)
- }
-
- fn emit_enum_struct_variant<F>(&mut self,
- name: &str,
- id: uint,
- cnt: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- self.emit_enum_variant(name, id, cnt, f)
- }
-
- fn emit_enum_struct_variant_field<F>(&mut self,
- _: &str,
- idx: uint,
- f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- self.emit_enum_variant_arg(idx, f)
- }
-
-
- fn emit_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if len == 0 {
- write!(self.writer, "{{}}")
- } else {
- try!(write!(self.writer, "{{"));
- self.curr_indent += self.indent;
- try!(f(self));
- self.curr_indent -= self.indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, self.curr_indent));
- write!(self.writer, "}}")
- }
- }
-
- fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if idx == 0 {
- try!(write!(self.writer, "\n"));
- } else {
- try!(write!(self.writer, ",\n"));
- }
- try!(spaces(self.writer, self.curr_indent));
- try!(escape_str(self.writer, name));
- try!(write!(self.writer, ": "));
- f(self)
- }
-
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- self.emit_seq(len, f)
- }
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- self.emit_seq(len, f)
- }
- fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- self.emit_seq_elt(idx, f)
- }
-
- fn emit_option<F>(&mut self, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- f(self)
- }
- fn emit_option_none(&mut self) -> EncodeResult { self.emit_nil() }
- fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- f(self)
- }
-
- fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if len == 0 {
- write!(self.writer, "[]")
- } else {
- try!(write!(self.writer, "["));
- self.curr_indent += self.indent;
- try!(f(self));
- self.curr_indent -= self.indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, self.curr_indent));
- write!(self.writer, "]")
- }
- }
-
- fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if idx == 0 {
- try!(write!(self.writer, "\n"));
- } else {
- try!(write!(self.writer, ",\n"));
- }
- try!(spaces(self.writer, self.curr_indent));
- f(self)
- }
-
- fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if len == 0 {
- write!(self.writer, "{{}}")
- } else {
- try!(write!(self.writer, "{{"));
- self.curr_indent += self.indent;
- try!(f(self));
- self.curr_indent -= self.indent;
- try!(write!(self.writer, "\n"));
- try!(spaces(self.writer, self.curr_indent));
- write!(self.writer, "}}")
- }
- }
-
- fn emit_map_elt_key<F>(&mut self, idx: uint, mut f: F) -> EncodeResult where
- F: FnMut(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- if idx == 0 {
- try!(write!(self.writer, "\n"));
- } else {
- try!(write!(self.writer, ",\n"));
- }
- try!(spaces(self.writer, self.curr_indent));
- // ref #12967, make sure to wrap a key in double quotes,
- // in the event that its of a type that omits them (eg numbers)
- let mut buf = Vec::new();
- // FIXME(14302) remove the transmute and unsafe block.
- unsafe {
- let mut check_encoder = PrettyEncoder::new(&mut buf);
- try!(f(transmute(&mut check_encoder)));
- }
- let out = str::from_utf8(buf[]).unwrap();
- let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
- if needs_wrapping { try!(write!(self.writer, "\"")); }
- try!(f(self));
- if needs_wrapping { try!(write!(self.writer, "\"")); }
- Ok(())
- }
-
- fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
- F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
- {
- try!(write!(self.writer, ": "));
- f(self)
- }
-}
-
-impl<E: ::Encoder<S>, S> Encodable<E, S> for Json {
- fn encode(&self, e: &mut E) -> Result<(), S> {
- match *self {
- Json::I64(v) => v.encode(e),
- Json::U64(v) => v.encode(e),
- Json::F64(v) => v.encode(e),
- Json::String(ref v) => v.encode(e),
- Json::Boolean(v) => v.encode(e),
- Json::Array(ref v) => v.encode(e),
- Json::Object(ref v) => v.encode(e),
- Json::Null => e.emit_nil(),
- }
- }
-}
-
-/// Create an `AsJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_json<T>(t: &T) -> AsJson<T> {
- AsJson { inner: t }
-}
-
-/// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_pretty_json<T>(t: &T) -> AsPrettyJson<T> {
- AsPrettyJson { inner: t, indent: None }
-}
-
-impl Json {
- /// Borrow this json object as a pretty object to generate a pretty
- /// representation for it via `Show`.
- pub fn pretty(&self) -> PrettyJson {
- PrettyJson { inner: self }
- }
-
- /// If the Json value is an Object, returns the value associated with the provided key.
- /// Otherwise, returns None.
- pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
- match self {
- &Json::Object(ref map) => map.get(key),
- _ => None
- }
- }
-
- /// Attempts to get a nested Json Object for each key in `keys`.
- /// If any key is found not to exist, find_path will return None.
- /// Otherwise, it will return the Json value associated with the final key.
- pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
- let mut target = self;
- for key in keys.iter() {
- match target.find(*key) {
- Some(t) => { target = t; },
- None => return None
- }
- }
- Some(target)
- }
-
- /// If the Json value is an Object, performs a depth-first search until
- /// a value associated with the provided key is found. If no value is found
- /// or the Json value is not an Object, returns None.
- pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
- match self {
- &Json::Object(ref map) => {
- match map.get(key) {
- Some(json_value) => Some(json_value),
- None => {
- for (_, v) in map.iter() {
- match v.search(key) {
- x if x.is_some() => return x,
- _ => ()
- }
- }
- None
- }
- }
- },
- _ => None
- }
- }
-
- /// Returns true if the Json value is an Object. Returns false otherwise.
- pub fn is_object<'a>(&'a self) -> bool {
- self.as_object().is_some()
- }
-
- /// If the Json value is an Object, returns the associated BTreeMap.
- /// Returns None otherwise.
- pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
- match self {
- &Json::Object(ref map) => Some(map),
- _ => None
- }
- }
-
- /// Returns true if the Json value is an Array. Returns false otherwise.
- pub fn is_array<'a>(&'a self) -> bool {
- self.as_array().is_some()
- }
-
- /// If the Json value is an Array, returns the associated vector.
- /// Returns None otherwise.
- pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
- match self {
- &Json::Array(ref array) => Some(&*array),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a String. Returns false otherwise.
- pub fn is_string<'a>(&'a self) -> bool {
- self.as_string().is_some()
- }
-
- /// If the Json value is a String, returns the associated str.
- /// Returns None otherwise.
- pub fn as_string<'a>(&'a self) -> Option<&'a str> {
- match *self {
- Json::String(ref s) => Some(s[]),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a Number. Returns false otherwise.
- pub fn is_number(&self) -> bool {
- match *self {
- Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
- _ => false,
- }
- }
-
- /// Returns true if the Json value is a i64. Returns false otherwise.
- pub fn is_i64(&self) -> bool {
- match *self {
- Json::I64(_) => true,
- _ => false,
- }
- }
-
- /// Returns true if the Json value is a u64. Returns false otherwise.
- pub fn is_u64(&self) -> bool {
- match *self {
- Json::U64(_) => true,
- _ => false,
- }
- }
-
- /// Returns true if the Json value is a f64. Returns false otherwise.
- pub fn is_f64(&self) -> bool {
- match *self {
- Json::F64(_) => true,
- _ => false,
- }
- }
-
- /// If the Json value is a number, return or cast it to a i64.
- /// Returns None otherwise.
- pub fn as_i64(&self) -> Option<i64> {
- match *self {
- Json::I64(n) => Some(n),
- Json::U64(n) => num::cast(n),
- _ => None
- }
- }
-
- /// If the Json value is a number, return or cast it to a u64.
- /// Returns None otherwise.
- pub fn as_u64(&self) -> Option<u64> {
- match *self {
- Json::I64(n) => num::cast(n),
- Json::U64(n) => Some(n),
- _ => None
- }
- }
-
- /// If the Json value is a number, return or cast it to a f64.
- /// Returns None otherwise.
- pub fn as_f64(&self) -> Option<f64> {
- match *self {
- Json::I64(n) => num::cast(n),
- Json::U64(n) => num::cast(n),
- Json::F64(n) => Some(n),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a Boolean. Returns false otherwise.
- pub fn is_boolean(&self) -> bool {
- self.as_boolean().is_some()
- }
-
- /// If the Json value is a Boolean, returns the associated bool.
- /// Returns None otherwise.
- pub fn as_boolean(&self) -> Option<bool> {
- match self {
- &Json::Boolean(b) => Some(b),
- _ => None
- }
- }
-
- /// Returns true if the Json value is a Null. Returns false otherwise.
- pub fn is_null(&self) -> bool {
- self.as_null().is_some()
- }
-
- /// If the Json value is a Null, returns ().
- /// Returns None otherwise.
- pub fn as_null(&self) -> Option<()> {
- match self {
- &Json::Null => Some(()),
- _ => None
- }
- }
-}
-
-impl<'a> ops::Index<&'a str> for Json {
- type Output = Json;
-
- fn index(&self, idx: & &str) -> &Json {
- self.find(*idx).unwrap()
- }
-}
-
-impl ops::Index<uint> for Json {
- type Output = Json;
-
- fn index<'a>(&'a self, idx: &uint) -> &'a Json {
- match self {
- &Json::Array(ref v) => v.index(idx),
- _ => panic!("can only index Json with uint if it is an array")
- }
- }
-}
-
-/// The output of the streaming parser.
-#[derive(PartialEq, Clone, Show)]
-pub enum JsonEvent {
- ObjectStart,
- ObjectEnd,
- ArrayStart,
- ArrayEnd,
- BooleanValue(bool),
- I64Value(i64),
- U64Value(u64),
- F64Value(f64),
- StringValue(string::String),
- NullValue,
- Error(ParserError),
-}
-
-#[derive(PartialEq, Show)]
-enum ParserState {
- // Parse a value in an array, true means first element.
- ParseArray(bool),
- // Parse ',' or ']' after an element in an array.
- ParseArrayComma,
- // Parse a key:value in an object, true means first element.
- ParseObject(bool),
- // Parse ',' or ']' after an element in an object.
- ParseObjectComma,
- // Initial state.
- ParseStart,
- // Expecting the stream to end.
- ParseBeforeFinish,
- // Parsing can't continue.
- ParseFinished,
-}
-
-/// A Stack represents the current position of the parser in the logical
-/// structure of the JSON stream.
-/// For example foo.bar[3].x
-pub struct Stack {
- stack: Vec<InternalStackElement>,
- str_buffer: Vec<u8>,
-}
-
-/// StackElements compose a Stack.
-/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
-/// StackElements compositing the stack that represents foo.bar[3].x
-#[derive(PartialEq, Clone, Show)]
-pub enum StackElement<'l> {
- Index(u32),
- Key(&'l str),
-}
-
-// Internally, Key elements are stored as indices in a buffer to avoid
-// allocating a string for every member of an object.
-#[derive(PartialEq, Clone, Show)]
-enum InternalStackElement {
- InternalIndex(u32),
- InternalKey(u16, u16), // start, size
-}
-
-impl Stack {
- pub fn new() -> Stack {
- Stack { stack: Vec::new(), str_buffer: Vec::new() }
- }
-
- /// Returns The number of elements in the Stack.
- pub fn len(&self) -> uint { self.stack.len() }
-
- /// Returns true if the stack is empty.
- pub fn is_empty(&self) -> bool { self.stack.is_empty() }
-
- /// Provides access to the StackElement at a given index.
- /// lower indices are at the bottom of the stack while higher indices are
- /// at the top.
- pub fn get<'l>(&'l self, idx: uint) -> StackElement<'l> {
- match self.stack[idx] {
- InternalIndex(i) => Index(i),
- InternalKey(start, size) => {
- Key(str::from_utf8(
- self.str_buffer[start as uint .. start as uint + size as uint]).unwrap())
- }
- }
- }
-
- /// Compares this stack with an array of StackElements.
- pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
- if self.stack.len() != rhs.len() { return false; }
- for i in range(0, rhs.len()) {
- if self.get(i) != rhs[i] { return false; }
- }
- return true;
- }
-
- /// Returns true if the bottom-most elements of this stack are the same as
- /// the ones passed as parameter.
- pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
- if self.stack.len() < rhs.len() { return false; }
- for i in range(0, rhs.len()) {
- if self.get(i) != rhs[i] { return false; }
- }
- return true;
- }
-
- /// Returns true if the top-most elements of this stack are the same as
- /// the ones passed as parameter.
- pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
- if self.stack.len() < rhs.len() { return false; }
- let offset = self.stack.len() - rhs.len();
- for i in range(0, rhs.len()) {
- if self.get(i + offset) != rhs[i] { return false; }
- }
- return true;
- }
-
- /// Returns the top-most element (if any).
- pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
- return match self.stack.last() {
- None => None,
- Some(&InternalIndex(i)) => Some(Index(i)),
- Some(&InternalKey(start, size)) => {
- Some(Key(str::from_utf8(
- self.str_buffer[start as uint .. (start+size) as uint]
- ).unwrap()))
- }
- }
- }
-
- // Used by Parser to insert Key elements at the top of the stack.
- fn push_key(&mut self, key: string::String) {
- self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
- for c in key.as_bytes().iter() {
- self.str_buffer.push(*c);
- }
- }
-
- // Used by Parser to insert Index elements at the top of the stack.
- fn push_index(&mut self, index: u32) {
- self.stack.push(InternalIndex(index));
- }
-
- // Used by Parser to remove the top-most element of the stack.
- fn pop(&mut self) {
- assert!(!self.is_empty());
- match *self.stack.last().unwrap() {
- InternalKey(_, sz) => {
- let new_size = self.str_buffer.len() - sz as uint;
- self.str_buffer.truncate(new_size);
- }
- InternalIndex(_) => {}
- }
- self.stack.pop();
- }
-
- // Used by Parser to test whether the top-most element is an index.
- fn last_is_index(&self) -> bool {
- if self.is_empty() { return false; }
- return match *self.stack.last().unwrap() {
- InternalIndex(_) => true,
- _ => false,
- }
- }
-
- // Used by Parser to increment the index of the top-most element.
- fn bump_index(&mut self) {
- let len = self.stack.len();
- let idx = match *self.stack.last().unwrap() {
- InternalIndex(i) => { i + 1 }
- _ => { panic!(); }
- };
- self.stack[len - 1] = InternalIndex(idx);
- }
-}
-
-/// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
-/// an iterator of char.
-pub struct Parser<T> {
- rdr: T,
- ch: Option<char>,
- line: uint,
- col: uint,
- // We maintain a stack representing where we are in the logical structure
- // of the JSON stream.
- stack: Stack,
- // A state machine is kept to make it possible to interrupt and resume parsing.
- state: ParserState,
-}
-
-impl<T: Iterator<Item=char>> Iterator for Parser<T> {
- type Item = JsonEvent;
-
- fn next(&mut self) -> Option<JsonEvent> {
- if self.state == ParseFinished {
- return None;
- }
-
- if self.state == ParseBeforeFinish {
- self.parse_whitespace();
- // Make sure there is no trailing characters.
- if self.eof() {
- self.state = ParseFinished;
- return None;
- } else {
- return Some(self.error_event(TrailingCharacters));
- }
- }
-
- return Some(self.parse());
- }
-}
-
-impl<T: Iterator<Item=char>> Parser<T> {
- /// Creates the JSON parser.
- pub fn new(rdr: T) -> Parser<T> {
- let mut p = Parser {
- rdr: rdr,
- ch: Some('\x00'),
- line: 1,
- col: 0,
- stack: Stack::new(),
- state: ParseStart,
- };
- p.bump();
- return p;
- }
-
- /// Provides access to the current position in the logical structure of the
- /// JSON stream.
- pub fn stack<'l>(&'l self) -> &'l Stack {
- return &self.stack;
- }
-
- fn eof(&self) -> bool { self.ch.is_none() }
- fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
- fn bump(&mut self) {
- self.ch = self.rdr.next();
-
- if self.ch_is('\n') {
- self.line += 1u;
- self.col = 1u;
- } else {
- self.col += 1u;
- }
- }
-
- fn next_char(&mut self) -> Option<char> {
- self.bump();
- self.ch
- }
- fn ch_is(&self, c: char) -> bool {
- self.ch == Some(c)
- }
-
- fn error<T>(&self, reason: ErrorCode) -> Result<T, ParserError> {
- Err(SyntaxError(reason, self.line, self.col))
- }
-
- fn parse_whitespace(&mut self) {
- while self.ch_is(' ') ||
- self.ch_is('\n') ||
- self.ch_is('\t') ||
- self.ch_is('\r') { self.bump(); }
- }
-
- fn parse_number(&mut self) -> JsonEvent {
- let mut neg = false;
-
- if self.ch_is('-') {
- self.bump();
- neg = true;
- }
-
- let res = match self.parse_u64() {
- Ok(res) => res,
- Err(e) => { return Error(e); }
- };
-
- if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
- let mut res = res as f64;
-
- if self.ch_is('.') {
- res = match self.parse_decimal(res) {
- Ok(res) => res,
- Err(e) => { return Error(e); }
- };
- }
-
- if self.ch_is('e') || self.ch_is('E') {
- res = match self.parse_exponent(res) {
- Ok(res) => res,
- Err(e) => { return Error(e); }
- };
- }
-
- if neg {
- res *= -1.0;
- }
-
- F64Value(res)
- } else {
- if neg {
- let res = -(res as i64);
-
- // Make sure we didn't underflow.
- if res > 0 {
- Error(SyntaxError(InvalidNumber, self.line, self.col))
- } else {
- I64Value(res)
- }
- } else {
- U64Value(res)
- }
- }
- }
-
- fn parse_u64(&mut self) -> Result<u64, ParserError> {
- let mut accum = 0;
- let last_accum = 0; // necessary to detect overflow.
-
- match self.ch_or_null() {
- '0' => {
- self.bump();
-
- // A leading '0' must be the only digit before the decimal point.
- match self.ch_or_null() {
- '0' ... '9' => return self.error(InvalidNumber),
- _ => ()
- }
- },
- '1' ... '9' => {
- while !self.eof() {
- match self.ch_or_null() {
- c @ '0' ... '9' => {
- accum *= 10;
- accum += (c as u64) - ('0' as u64);
-
- // Detect overflow by comparing to the last value.
- if accum <= last_accum { return self.error(InvalidNumber); }
-
- self.bump();
- }
- _ => break,
- }
- }
- }
- _ => return self.error(InvalidNumber),
- }
-
- Ok(accum)
- }
-
- fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
- self.bump();
-
- // Make sure a digit follows the decimal place.
- match self.ch_or_null() {
- '0' ... '9' => (),
- _ => return self.error(InvalidNumber)
- }
-
- let mut dec = 1.0;
- while !self.eof() {
- match self.ch_or_null() {
- c @ '0' ... '9' => {
- dec /= 10.0;
- res += (((c as int) - ('0' as int)) as f64) * dec;
- self.bump();
- }
- _ => break,
- }
- }
-
- Ok(res)
- }
-
- fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
- self.bump();
-
- let mut exp = 0u;
- let mut neg_exp = false;
-
- if self.ch_is('+') {
- self.bump();
- } else if self.ch_is('-') {
- self.bump();
- neg_exp = true;
- }
-
- // Make sure a digit follows the exponent place.
- match self.ch_or_null() {
- '0' ... '9' => (),
- _ => return self.error(InvalidNumber)
- }
- while !self.eof() {
- match self.ch_or_null() {
- c @ '0' ... '9' => {
- exp *= 10;
- exp += (c as uint) - ('0' as uint);
-
- self.bump();
- }
- _ => break
- }
- }
-
- let exp = 10_f64.powi(exp as i32);
- if neg_exp {
- res /= exp;
- } else {
- res *= exp;
- }
-
- Ok(res)
- }
-
- fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
- let mut i = 0u;
- let mut n = 0u16;
- while i < 4 && !self.eof() {
- self.bump();
- n = match self.ch_or_null() {
- c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
- 'a' | 'A' => n * 16 + 10,
- 'b' | 'B' => n * 16 + 11,
- 'c' | 'C' => n * 16 + 12,
- 'd' | 'D' => n * 16 + 13,
- 'e' | 'E' => n * 16 + 14,
- 'f' | 'F' => n * 16 + 15,
- _ => return self.error(InvalidEscape)
- };
-
- i += 1u;
- }
-
- // Error out if we didn't parse 4 digits.
- if i != 4 {
- return self.error(InvalidEscape);
- }
-
- Ok(n)
- }
-
- fn parse_str(&mut self) -> Result<string::String, ParserError> {
- let mut escape = false;
- let mut res = string::String::new();
-
- loop {
- self.bump();
- if self.eof() {
- return self.error(EOFWhileParsingString);
- }
-
- if escape {
- match self.ch_or_null() {
- '"' => res.push('"'),
- '\\' => res.push('\\'),
- '/' => res.push('/'),
- 'b' => res.push('\x08'),
- 'f' => res.push('\x0c'),
- 'n' => res.push('\n'),
- 'r' => res.push('\r'),
- 't' => res.push('\t'),
- 'u' => match try!(self.decode_hex_escape()) {
- 0xDC00 ... 0xDFFF => {
- return self.error(LoneLeadingSurrogateInHexEscape)
- }
-
- // Non-BMP characters are encoded as a sequence of
- // two hex escapes, representing UTF-16 surrogates.
- n1 @ 0xD800 ... 0xDBFF => {
- match (self.next_char(), self.next_char()) {
- (Some('\\'), Some('u')) => (),
- _ => return self.error(UnexpectedEndOfHexEscape),
- }
-
- let buf = [n1, try!(self.decode_hex_escape())];
- match unicode_str::utf16_items(&buf).next() {
- Some(Utf16Item::ScalarValue(c)) => res.push(c),
- _ => return self.error(LoneLeadingSurrogateInHexEscape),
- }
- }
-
- n => match char::from_u32(n as u32) {
- Some(c) => res.push(c),
- None => return self.error(InvalidUnicodeCodePoint),
- },
- },
- _ => return self.error(InvalidEscape),
- }
- escape = false;
- } else if self.ch_is('\\') {
- escape = true;
- } else {
- match self.ch {
- Some('"') => {
- self.bump();
- return Ok(res);
- },
- Some(c) => res.push(c),
- None => unreachable!()
- }
- }
- }
- }
-
- // Invoked at each iteration, consumes the stream until it has enough
- // information to return a JsonEvent.
- // Manages an internal state so that parsing can be interrupted and resumed.
- // Also keeps track of the position in the logical structure of the json
- // stream int the form of a stack that can be queried by the user using the
- // stack() method.
- fn parse(&mut self) -> JsonEvent {
- loop {
- // The only paths where the loop can spin a new iteration
- // are in the cases ParseArrayComma and ParseObjectComma if ','
- // is parsed. In these cases the state is set to (respectively)
- // ParseArray(false) and ParseObject(false), which always return,
- // so there is no risk of getting stuck in an infinite loop.
- // All other paths return before the end of the loop's iteration.
- self.parse_whitespace();
-
- match self.state {
- ParseStart => {
- return self.parse_start();
- }
- ParseArray(first) => {
- return self.parse_array(first);
- }
- ParseArrayComma => {
- match self.parse_array_comma_or_end() {
- Some(evt) => { return evt; }
- None => {}
- }
- }
- ParseObject(first) => {
- return self.parse_object(first);
- }
- ParseObjectComma => {
- self.stack.pop();
- if self.ch_is(',') {
- self.state = ParseObject(false);
- self.bump();
- } else {
- return self.parse_object_end();
- }
- }
- _ => {
- return self.error_event(InvalidSyntax);
- }
- }
- }
- }
-
- fn parse_start(&mut self) -> JsonEvent {
- let val = self.parse_value();
- self.state = match val {
- Error(_) => ParseFinished,
- ArrayStart => ParseArray(true),
- ObjectStart => ParseObject(true),
- _ => ParseBeforeFinish,
- };
- return val;
- }
-
- fn parse_array(&mut self, first: bool) -> JsonEvent {
- if self.ch_is(']') {
- if !first {
- self.error_event(InvalidSyntax)
- } else {
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- ArrayEnd
- }
- } else {
- if first {
- self.stack.push_index(0);
- }
- let val = self.parse_value();
- self.state = match val {
- Error(_) => ParseFinished,
- ArrayStart => ParseArray(true),
- ObjectStart => ParseObject(true),
- _ => ParseArrayComma,
- };
- val
- }
- }
-
- fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
- if self.ch_is(',') {
- self.stack.bump_index();
- self.state = ParseArray(false);
- self.bump();
- None
- } else if self.ch_is(']') {
- self.stack.pop();
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- Some(ArrayEnd)
- } else if self.eof() {
- Some(self.error_event(EOFWhileParsingArray))
- } else {
- Some(self.error_event(InvalidSyntax))
- }
- }
-
- fn parse_object(&mut self, first: bool) -> JsonEvent {
- if self.ch_is('}') {
- if !first {
- if self.stack.is_empty() {
- return self.error_event(TrailingComma);
- } else {
- self.stack.pop();
- }
- }
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- return ObjectEnd;
- }
- if self.eof() {
- return self.error_event(EOFWhileParsingObject);
- }
- if !self.ch_is('"') {
- return self.error_event(KeyMustBeAString);
- }
- let s = match self.parse_str() {
- Ok(s) => s,
- Err(e) => {
- self.state = ParseFinished;
- return Error(e);
- }
- };
- self.parse_whitespace();
- if self.eof() {
- return self.error_event(EOFWhileParsingObject);
- } else if self.ch_or_null() != ':' {
- return self.error_event(ExpectedColon);
- }
- self.stack.push_key(s);
- self.bump();
- self.parse_whitespace();
-
- let val = self.parse_value();
-
- self.state = match val {
- Error(_) => ParseFinished,
- ArrayStart => ParseArray(true),
- ObjectStart => ParseObject(true),
- _ => ParseObjectComma,
- };
- return val;
- }
-
- fn parse_object_end(&mut self) -> JsonEvent {
- if self.ch_is('}') {
- self.state = if self.stack.is_empty() {
- ParseBeforeFinish
- } else if self.stack.last_is_index() {
- ParseArrayComma
- } else {
- ParseObjectComma
- };
- self.bump();
- ObjectEnd
- } else if self.eof() {
- self.error_event(EOFWhileParsingObject)
- } else {
- self.error_event(InvalidSyntax)
- }
- }
-
- fn parse_value(&mut self) -> JsonEvent {
- if self.eof() { return self.error_event(EOFWhileParsingValue); }
- match self.ch_or_null() {
- 'n' => { self.parse_ident("ull", NullValue) }
- 't' => { self.parse_ident("rue", BooleanValue(true)) }
- 'f' => { self.parse_ident("alse", BooleanValue(false)) }
- '0' ... '9' | '-' => self.parse_number(),
- '"' => match self.parse_str() {
- Ok(s) => StringValue(s),
- Err(e) => Error(e),
- },
- '[' => {
- self.bump();
- ArrayStart
- }
- '{' => {
- self.bump();
- ObjectStart
- }
- _ => { self.error_event(InvalidSyntax) }
- }
- }
-
- fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
- if ident.chars().all(|c| Some(c) == self.next_char()) {
- self.bump();
- value
- } else {
- Error(SyntaxError(InvalidSyntax, self.line, self.col))
- }
- }
-
- fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
- self.state = ParseFinished;
- Error(SyntaxError(reason, self.line, self.col))
- }
-}
-
-/// A Builder consumes a json::Parser to create a generic Json structure.
-pub struct Builder<T> {
- parser: Parser<T>,
- token: Option<JsonEvent>,
-}
-
-impl<T: Iterator<Item=char>> Builder<T> {
- /// Create a JSON Builder.
- pub fn new(src: T) -> Builder<T> {
- Builder { parser: Parser::new(src), token: None, }
- }
-
- // Decode a Json value from a Parser.
- pub fn build(&mut self) -> Result<Json, BuilderError> {
- self.bump();
- let result = self.build_value();
- self.bump();
- match self.token {
- None => {}
- Some(Error(e)) => { return Err(e); }
- ref tok => { panic!("unexpected token {}", tok.clone()); }
- }
- result
- }
-
- fn bump(&mut self) {
- self.token = self.parser.next();
- }
-
- fn build_value(&mut self) -> Result<Json, BuilderError> {
- return match self.token {
- Some(NullValue) => Ok(Json::Null),
- Some(I64Value(n)) => Ok(Json::I64(n)),
- Some(U64Value(n)) => Ok(Json::U64(n)),
- Some(F64Value(n)) => Ok(Json::F64(n)),
- Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
- Some(StringValue(ref mut s)) => {
- let mut temp = string::String::new();
- swap(s, &mut temp);
- Ok(Json::String(temp))
- }
- Some(Error(e)) => Err(e),
- Some(ArrayStart) => self.build_array(),
- Some(ObjectStart) => self.build_object(),
- Some(ObjectEnd) => self.parser.error(InvalidSyntax),
- Some(ArrayEnd) => self.parser.error(InvalidSyntax),
- None => self.parser.error(EOFWhileParsingValue),
- }
- }
-
- fn build_array(&mut self) -> Result<Json, BuilderError> {
- self.bump();
- let mut values = Vec::new();
-
- loop {
- if self.token == Some(ArrayEnd) {
- return Ok(Json::Array(values.into_iter().collect()));
- }
- match self.build_value() {
- Ok(v) => values.push(v),
- Err(e) => { return Err(e) }
- }
- self.bump();
- }
- }
-
- fn build_object(&mut self) -> Result<Json, BuilderError> {
- self.bump();
-
- let mut values = BTreeMap::new();
-
- loop {
- match self.token {
- Some(ObjectEnd) => { return Ok(Json::Object(values)); }
- Some(Error(e)) => { return Err(e); }
- None => { break; }
- _ => {}
- }
- let key = match self.parser.stack().top() {
- Some(Key(k)) => { k.to_string() }
- _ => { panic!("invalid state"); }
- };
- match self.build_value() {
- Ok(value) => { values.insert(key, value); }
- Err(e) => { return Err(e); }
- }
- self.bump();
- }
- return self.parser.error(EOFWhileParsingObject);
- }
-}
-
-/// Decodes a json value from an `&mut io::Reader`
-pub fn from_reader(rdr: &mut io::Reader) -> Result<Json, BuilderError> {
- let contents = match rdr.read_to_end() {
- Ok(c) => c,
- Err(e) => return Err(io_error_to_error(e))
- };
- let s = match str::from_utf8(contents.as_slice()).ok() {
- Some(s) => s,
- _ => return Err(SyntaxError(NotUtf8, 0, 0))
- };
- let mut builder = Builder::new(s.chars());
- builder.build()
-}
-
-/// Decodes a json value from a string
-pub fn from_str(s: &str) -> Result<Json, BuilderError> {
- let mut builder = Builder::new(s.chars());
- builder.build()
-}
-
-/// A structure to decode JSON to values in rust.
-pub struct Decoder {
- stack: Vec<Json>,
-}
-
-impl Decoder {
- /// Creates a new decoder instance for decoding the specified JSON value.
- pub fn new(json: Json) -> Decoder {
- Decoder { stack: vec![json] }
- }
-}
-
-impl Decoder {
- fn pop(&mut self) -> Json {
- self.stack.pop().unwrap()
- }
-}
-
-macro_rules! expect {
- ($e:expr, Null) => ({
- match $e {
- Json::Null => Ok(()),
- other => Err(ExpectedError("Null".to_string(),
- format!("{}", other)))
- }
- });
- ($e:expr, $t:ident) => ({
- match $e {
- Json::$t(v) => Ok(v),
- other => {
- Err(ExpectedError(stringify!($t).to_string(),
- format!("{}", other)))
- }
- }
- })
-}
-
-macro_rules! read_primitive {
- ($name:ident, $ty:ty) => {
- fn $name(&mut self) -> DecodeResult<$ty> {
- match self.pop() {
- Json::I64(f) => match num::cast(f) {
- Some(f) => Ok(f),
- None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
- },
- Json::U64(f) => match num::cast(f) {
- Some(f) => Ok(f),
- None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
- },
- Json::F64(f) => Err(ExpectedError("Integer".to_string(), format!("{}", f))),
- // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
- // is going to have a string here, as per JSON spec.
- Json::String(s) => match s.parse() {
- Some(f) => Ok(f),
- None => Err(ExpectedError("Number".to_string(), s)),
- },
- value => Err(ExpectedError("Number".to_string(), format!("{}", value))),
- }
- }
- }
-}
-
-impl ::Decoder<DecoderError> for Decoder {
- fn read_nil(&mut self) -> DecodeResult<()> {
- expect!(self.pop(), Null)
- }
-
- read_primitive! { read_uint, uint }
- read_primitive! { read_u8, u8 }
- read_primitive! { read_u16, u16 }
- read_primitive! { read_u32, u32 }
- read_primitive! { read_u64, u64 }
- read_primitive! { read_int, int }
- read_primitive! { read_i8, i8 }
- read_primitive! { read_i16, i16 }
- read_primitive! { read_i32, i32 }
- read_primitive! { read_i64, i64 }
-
- fn read_f32(&mut self) -> DecodeResult<f32> { self.read_f64().map(|x| x as f32) }
-
- fn read_f64(&mut self) -> DecodeResult<f64> {
- match self.pop() {
- Json::I64(f) => Ok(f as f64),
- Json::U64(f) => Ok(f as f64),
- Json::F64(f) => Ok(f),
- Json::String(s) => {
- // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
- // is going to have a string here, as per JSON spec.
- match s.parse() {
- Some(f) => Ok(f),
- None => Err(ExpectedError("Number".to_string(), s)),
- }
- },
- Json::Null => Ok(f64::NAN),
- value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
- }
- }
-
- fn read_bool(&mut self) -> DecodeResult<bool> {
- expect!(self.pop(), Boolean)
- }
-
- fn read_char(&mut self) -> DecodeResult<char> {
- let s = try!(self.read_str());
- {
- let mut it = s.chars();
- match (it.next(), it.next()) {
- // exactly one character
- (Some(c), None) => return Ok(c),
- _ => ()
- }
- }
- Err(ExpectedError("single character string".to_string(), format!("{}", s)))
- }
-
- fn read_str(&mut self) -> DecodeResult<string::String> {
- expect!(self.pop(), String)
- }
-
- fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_enum_variant<T, F>(&mut self, names: &[&str],
- mut f: F) -> DecodeResult<T>
- where F: FnMut(&mut Decoder, uint) -> DecodeResult<T>,
- {
- let name = match self.pop() {
- Json::String(s) => s,
- Json::Object(mut o) => {
- let n = match o.remove(&"variant".to_string()) {
- Some(Json::String(s)) => s,
- Some(val) => {
- return Err(ExpectedError("String".to_string(), format!("{}", val)))
- }
- None => {
- return Err(MissingFieldError("variant".to_string()))
- }
- };
- match o.remove(&"fields".to_string()) {
- Some(Json::Array(l)) => {
- for field in l.into_iter().rev() {
- self.stack.push(field);
- }
- },
- Some(val) => {
- return Err(ExpectedError("Array".to_string(), format!("{}", val)))
- }
- None => {
- return Err(MissingFieldError("fields".to_string()))
- }
- }
- n
- }
- json => {
- return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
- }
- };
- let idx = match names.iter().position(|n| *n == name[]) {
- Some(idx) => idx,
- None => return Err(UnknownVariantError(name))
- };
- f(self, idx)
- }
-
- fn read_enum_variant_arg<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
- F: FnMut(&mut Decoder, uint) -> DecodeResult<T>,
- {
- self.read_enum_variant(names, f)
- }
-
-
- fn read_enum_struct_variant_field<T, F>(&mut self,
- _name: &str,
- idx: uint,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_enum_variant_arg(idx, f)
- }
-
- fn read_struct<T, F>(&mut self, _name: &str, _len: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- let value = try!(f(self));
- self.pop();
- Ok(value)
- }
-
- fn read_struct_field<T, F>(&mut self,
- name: &str,
- _idx: uint,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- let mut obj = try!(expect!(self.pop(), Object));
-
- let value = match obj.remove(&name.to_string()) {
- None => {
- // Add a Null and try to parse it as an Option<_>
- // to get None as a default value.
- self.stack.push(Json::Null);
- match f(self) {
- Ok(x) => x,
- Err(_) => return Err(MissingFieldError(name.to_string())),
- }
- },
- Some(json) => {
- self.stack.push(json);
- try!(f(self))
- }
- };
- self.stack.push(Json::Object(obj));
- Ok(value)
- }
-
- fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_seq(move |d, len| {
- if len == tuple_len {
- f(d)
- } else {
- Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len)))
- }
- })
- }
-
- fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_seq_elt(idx, f)
- }
-
- fn read_tuple_struct<T, F>(&mut self,
- _name: &str,
- len: uint,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_tuple(len, f)
- }
-
- fn read_tuple_struct_arg<T, F>(&mut self,
- idx: uint,
- f: F)
- -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- self.read_tuple_arg(idx, f)
- }
-
- fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
- F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
- {
- match self.pop() {
- Json::Null => f(self, false),
- value => { self.stack.push(value); f(self, true) }
- }
- }
-
- fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
- {
- let array = try!(expect!(self.pop(), Array));
- let len = array.len();
- for v in array.into_iter().rev() {
- self.stack.push(v);
- }
- f(self, len)
- }
-
- fn read_seq_elt<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
- {
- let obj = try!(expect!(self.pop(), Object));
- let len = obj.len();
- for (key, value) in obj.into_iter() {
- self.stack.push(value);
- self.stack.push(Json::String(key));
- }
- f(self, len)
- }
-
- fn read_map_elt_key<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn read_map_elt_val<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder) -> DecodeResult<T>,
- {
- f(self)
- }
-
- fn error(&mut self, err: &str) -> DecoderError {
- ApplicationError(err.to_string())
- }
-}
-
-/// A trait for converting values to JSON
-pub trait ToJson {
- /// Converts the value of `self` to an instance of JSON
- fn to_json(&self) -> Json;
-}
-
-macro_rules! to_json_impl_i64 {
- ($($t:ty), +) => (
- $(impl ToJson for $t {
- fn to_json(&self) -> Json { Json::I64(*self as i64) }
- })+
- )
-}
-
-to_json_impl_i64! { int, i8, i16, i32, i64 }
-
-macro_rules! to_json_impl_u64 {
- ($($t:ty), +) => (
- $(impl ToJson for $t {
- fn to_json(&self) -> Json { Json::U64(*self as u64) }
- })+
- )
-}
-
-to_json_impl_u64! { uint, u8, u16, u32, u64 }
-
-impl ToJson for Json {
- fn to_json(&self) -> Json { self.clone() }
-}
-
-impl ToJson for f32 {
- fn to_json(&self) -> Json { (*self as f64).to_json() }
-}
-
-impl ToJson for f64 {
- fn to_json(&self) -> Json {
- match self.classify() {
- Fp::Nan | Fp::Infinite => Json::Null,
- _ => Json::F64(*self)
- }
- }
-}
-
-impl ToJson for () {
- fn to_json(&self) -> Json { Json::Null }
-}
-
-impl ToJson for bool {
- fn to_json(&self) -> Json { Json::Boolean(*self) }
-}
-
-impl ToJson for str {
- fn to_json(&self) -> Json { Json::String(self.to_string()) }
-}
-
-impl ToJson for string::String {
- fn to_json(&self) -> Json { Json::String((*self).clone()) }
-}
-
-macro_rules! tuple_impl {
- // use variables to indicate the arity of the tuple
- ($($tyvar:ident),* ) => {
- // the trailing commas are for the 1 tuple
- impl<
- $( $tyvar : ToJson ),*
- > ToJson for ( $( $tyvar ),* , ) {
-
- #[inline]
- #[allow(non_snake_case)]
- fn to_json(&self) -> Json {
- match *self {
- ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
- }
- }
- }
- }
-}
-
-tuple_impl!{A}
-tuple_impl!{A, B}
-tuple_impl!{A, B, C}
-tuple_impl!{A, B, C, D}
-tuple_impl!{A, B, C, D, E}
-tuple_impl!{A, B, C, D, E, F}
-tuple_impl!{A, B, C, D, E, F, G}
-tuple_impl!{A, B, C, D, E, F, G, H}
-tuple_impl!{A, B, C, D, E, F, G, H, I}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
-
-impl<A: ToJson> ToJson for [A] {
- fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for Vec<A> {
- fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
- fn to_json(&self) -> Json {
- let mut d = BTreeMap::new();
- for (key, value) in self.iter() {
- d.insert((*key).clone(), value.to_json());
- }
- Json::Object(d)
- }
-}
-
-impl<A: ToJson> ToJson for HashMap<string::String, A> {
- fn to_json(&self) -> Json {
- let mut d = BTreeMap::new();
- for (key, value) in self.iter() {
- d.insert((*key).clone(), value.to_json());
- }
- Json::Object(d)
- }
-}
-
-impl<A:ToJson> ToJson for Option<A> {
- fn to_json(&self) -> Json {
- match *self {
- None => Json::Null,
- Some(ref value) => value.to_json()
- }
- }
-}
-
-struct FormatShim<'a, 'b: 'a> {
- inner: &'a mut fmt::Formatter<'b>,
-}
-
-impl<'a, 'b> fmt::Writer for FormatShim<'a, 'b> {
- fn write_str(&mut self, s: &str) -> fmt::Result {
- self.inner.write_str(s)
- }
-}
-
-impl fmt::Show for Json {
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = Encoder::new(&mut shim);
- self.encode(&mut encoder)
- }
-}
-
-impl<'a> fmt::Show for PrettyJson<'a> {
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = PrettyEncoder::new(&mut shim);
- self.inner.encode(&mut encoder)
- }
-}
-
-impl<'a, T> fmt::Show for AsJson<'a, T>
- where T: for<'b> Encodable<Encoder<'b>, fmt::Error>
-{
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = Encoder::new(&mut shim);
- self.inner.encode(&mut encoder)
- }
-}
-
-impl<'a, T> AsPrettyJson<'a, T> {
- /// Set the indentation level for the emitted JSON
- pub fn indent(mut self, indent: uint) -> AsPrettyJson<'a, T> {
- self.indent = Some(indent);
- self
- }
-}
-
-impl<'a, T> fmt::Show for AsPrettyJson<'a, T>
- where T: for<'b> Encodable<PrettyEncoder<'b>, fmt::Error>
-{
- /// Encodes a json value into a string
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let mut shim = FormatShim { inner: f };
- let mut encoder = PrettyEncoder::new(&mut shim);
- match self.indent {
- Some(n) => encoder.set_indent(n),
- None => {}
- }
- self.inner.encode(&mut encoder)
- }
-}
-
-impl FromStr for Json {
- fn from_str(s: &str) -> Option<Json> {
- from_str(s).ok()
- }
-}
-
-#[cfg(test)]
-mod tests {
- extern crate test;
- use self::Animal::*;
- use self::DecodeEnum::*;
- use self::test::Bencher;
- use {Encodable, Decodable};
- use super::Json::*;
- use super::ErrorCode::*;
- use super::ParserError::*;
- use super::DecoderError::*;
- use super::JsonEvent::*;
- use super::StackElement::*;
- use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser,
- StackElement, Stack, Decoder};
- use std::{i64, u64, f32, f64};
- use std::collections::BTreeMap;
- use std::num::Float;
- use std::string;
-
- #[derive(RustcDecodable, Eq, PartialEq, Show)]
- struct OptionData {
- opt: Option<uint>,
- }
-
- #[test]
- fn test_decode_option_none() {
- let s ="{}";
- let obj: OptionData = super::decode(s).unwrap();
- assert_eq!(obj, OptionData { opt: None });
- }
-
- #[test]
- fn test_decode_option_some() {
- let s = "{ \"opt\": 10 }";
- let obj: OptionData = super::decode(s).unwrap();
- assert_eq!(obj, OptionData { opt: Some(10u) });
- }
-
- #[test]
- fn test_decode_option_malformed() {
- check_err::<OptionData>("{ \"opt\": [] }",
- ExpectedError("Number".to_string(), "[]".to_string()));
- check_err::<OptionData>("{ \"opt\": false }",
- ExpectedError("Number".to_string(), "false".to_string()));
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Show)]
- enum Animal {
- Dog,
- Frog(string::String, int)
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Show)]
- struct Inner {
- a: (),
- b: uint,
- c: Vec<string::String>,
- }
-
- #[derive(PartialEq, RustcEncodable, RustcDecodable, Show)]
- struct Outer {
- inner: Vec<Inner>,
- }
-
- fn mk_object(items: &[(string::String, Json)]) -> Json {
- let mut d = BTreeMap::new();
-
- for item in items.iter() {
- match *item {
- (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
- }
- };
-
- Object(d)
- }
-
- #[test]
- fn test_from_str_trait() {
- let s = "null";
- assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
- }
-
- #[test]
- fn test_write_null() {
- assert_eq!(Null.to_string(), "null");
- assert_eq!(Null.pretty().to_string(), "null");
- }
-
- #[test]
- fn test_write_i64() {
- assert_eq!(U64(0).to_string(), "0");
- assert_eq!(U64(0).pretty().to_string(), "0");
-
- assert_eq!(U64(1234).to_string(), "1234");
- assert_eq!(U64(1234).pretty().to_string(), "1234");
-
- assert_eq!(I64(-5678).to_string(), "-5678");
- assert_eq!(I64(-5678).pretty().to_string(), "-5678");
-
- assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
- assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
- }
-
- #[test]
- fn test_write_f64() {
- assert_eq!(F64(3.0).to_string(), "3.0");
- assert_eq!(F64(3.0).pretty().to_string(), "3.0");
-
- assert_eq!(F64(3.1).to_string(), "3.1");
- assert_eq!(F64(3.1).pretty().to_string(), "3.1");
-
- assert_eq!(F64(-1.5).to_string(), "-1.5");
- assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
-
- assert_eq!(F64(0.5).to_string(), "0.5");
- assert_eq!(F64(0.5).pretty().to_string(), "0.5");
-
- assert_eq!(F64(f64::NAN).to_string(), "null");
- assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
-
- assert_eq!(F64(f64::INFINITY).to_string(), "null");
- assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
-
- assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
- assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
- }
-
- #[test]
- fn test_write_str() {
- assert_eq!(String("".to_string()).to_string(), "\"\"");
- assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
-
- assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
- assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
- }
-
- #[test]
- fn test_write_bool() {
- assert_eq!(Boolean(true).to_string(), "true");
- assert_eq!(Boolean(true).pretty().to_string(), "true");
-
- assert_eq!(Boolean(false).to_string(), "false");
- assert_eq!(Boolean(false).pretty().to_string(), "false");
- }
-
- #[test]
- fn test_write_array() {
- assert_eq!(Array(vec![]).to_string(), "[]");
- assert_eq!(Array(vec![]).pretty().to_string(), "[]");
-
- assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
- assert_eq!(
- Array(vec![Boolean(true)]).pretty().to_string(),
- "\
- [\n \
- true\n\
- ]"
- );
-
- let long_test_array = Array(vec![
- Boolean(false),
- Null,
- Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
-
- assert_eq!(long_test_array.to_string(),
- "[false,null,[\"foo\\nbar\",3.5]]");
- assert_eq!(
- long_test_array.pretty().to_string(),
- "\
- [\n \
- false,\n \
- null,\n \
- [\n \
- \"foo\\nbar\",\n \
- 3.5\n \
- ]\n\
- ]"
- );
- }
-
- #[test]
- fn test_write_object() {
- assert_eq!(mk_object(&[]).to_string(), "{}");
- assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
-
- assert_eq!(
- mk_object(&[
- ("a".to_string(), Boolean(true))
- ]).to_string(),
- "{\"a\":true}"
- );
- assert_eq!(
- mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
- "\
- {\n \
- \"a\": true\n\
- }"
- );
-
- let complex_obj = mk_object(&[
- ("b".to_string(), Array(vec![
- mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
- mk_object(&[("d".to_string(), String("".to_string()))])
- ]))
- ]);
-
- assert_eq!(
- complex_obj.to_string(),
- "{\
- \"b\":[\
- {\"c\":\"\\f\\r\"},\
- {\"d\":\"\"}\
- ]\
- }"
- );
- assert_eq!(
- complex_obj.pretty().to_string(),
- "\
- {\n \
- \"b\": [\n \
- {\n \
- \"c\": \"\\f\\r\"\n \
- },\n \
- {\n \
- \"d\": \"\"\n \
- }\n \
- ]\n\
- }"
- );
-
- let a = mk_object(&[
- ("a".to_string(), Boolean(true)),
- ("b".to_string(), Array(vec![
- mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
- mk_object(&[("d".to_string(), String("".to_string()))])
- ]))
- ]);
-
- // We can't compare the strings directly because the object fields be
- // printed in a different order.
- assert_eq!(a.clone(), a.to_string().parse().unwrap());
- assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
- }
-
- #[test]
- fn test_write_enum() {
- let animal = Dog;
- assert_eq!(
- format!("{}", super::as_json(&animal)),
- "\"Dog\""
- );
- assert_eq!(
- format!("{}", super::as_pretty_json(&animal)),
- "\"Dog\""
- );
-
- let animal = Frog("Henry".to_string(), 349);
- assert_eq!(
- format!("{}", super::as_json(&animal)),
- "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
- );
- assert_eq!(
- format!("{}", super::as_pretty_json(&animal)),
- "{\n \
- \"variant\": \"Frog\",\n \
- \"fields\": [\n \
- \"Henry\",\n \
- 349\n \
- ]\n\
- }"
- );
- }
-
- macro_rules! check_encoder_for_simple {
- ($value:expr, $expected:expr) => ({
- let s = format!("{}", super::as_json(&$value));
- assert_eq!(s, $expected);
-
- let s = format!("{}", super::as_pretty_json(&$value));
- assert_eq!(s, $expected);
- })
- }
-
- #[test]
- fn test_write_some() {
- check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
- }
-
- #[test]
- fn test_write_none() {
- check_encoder_for_simple!(None::<string::String>, "null");
- }
-
- #[test]
- fn test_write_char() {
- check_encoder_for_simple!('a', "\"a\"");
- check_encoder_for_simple!('\t', "\"\\t\"");
- check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
- check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
- check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
- check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
- check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
- check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
- }
-
- #[test]
- fn test_trailing_characters() {
- assert_eq!(from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
- assert_eq!(from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2)));
- assert_eq!(from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
- assert_eq!(from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
- }
-
- #[test]
- fn test_read_identifiers() {
- assert_eq!(from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3)));
-
- assert_eq!(from_str("null"), Ok(Null));
- assert_eq!(from_str("true"), Ok(Boolean(true)));
- assert_eq!(from_str("false"), Ok(Boolean(false)));
- assert_eq!(from_str(" null "), Ok(Null));
- assert_eq!(from_str(" true "), Ok(Boolean(true)));
- assert_eq!(from_str(" false "), Ok(Boolean(false)));
- }
-
- #[test]
- fn test_decode_identifiers() {
- let v: () = super::decode("null").unwrap();
- assert_eq!(v, ());
-
- let v: bool = super::decode("true").unwrap();
- assert_eq!(v, true);
-
- let v: bool = super::decode("false").unwrap();
- assert_eq!(v, false);
- }
-
- #[test]
- fn test_read_number() {
- assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
- assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
- assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
- assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
- assert_eq!(from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3)));
- assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
-
- assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
- assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
-
- assert_eq!(from_str("3"), Ok(U64(3)));
- assert_eq!(from_str("3.1"), Ok(F64(3.1)));
- assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
- assert_eq!(from_str("0.4"), Ok(F64(0.4)));
- assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5)));
- assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
- assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
- assert_eq!(from_str(" 3 "), Ok(U64(3)));
-
- assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
- assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
- assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
- }
-
- #[test]
- fn test_decode_numbers() {
- let v: f64 = super::decode("3").unwrap();
- assert_eq!(v, 3.0);
-
- let v: f64 = super::decode("3.1").unwrap();
- assert_eq!(v, 3.1);
-
- let v: f64 = super::decode("-1.2").unwrap();
- assert_eq!(v, -1.2);
-
- let v: f64 = super::decode("0.4").unwrap();
- assert_eq!(v, 0.4);
-
- let v: f64 = super::decode("0.4e5").unwrap();
- assert_eq!(v, 0.4e5);
-
- let v: f64 = super::decode("0.4e15").unwrap();
- assert_eq!(v, 0.4e15);
-
- let v: f64 = super::decode("0.4e-01").unwrap();
- assert_eq!(v, 0.4e-01);
-
- let v: u64 = super::decode("0").unwrap();
- assert_eq!(v, 0);
-
- let v: u64 = super::decode("18446744073709551615").unwrap();
- assert_eq!(v, u64::MAX);
-
- let v: i64 = super::decode("-9223372036854775808").unwrap();
- assert_eq!(v, i64::MIN);
-
- let v: i64 = super::decode("9223372036854775807").unwrap();
- assert_eq!(v, i64::MAX);
-
- let res: DecodeResult<i64> = super::decode("765.25252");
- assert_eq!(res, Err(ExpectedError("Integer".to_string(), "765.25252".to_string())));
- }
-
- #[test]
- fn test_read_str() {
- assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
- assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
-
- assert_eq!(from_str("\"\""), Ok(String("".to_string())));
- assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string())));
- assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
- assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string())));
- assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string())));
- assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string())));
- assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string())));
- assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string())));
- assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
- assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
- }
-
- #[test]
- fn test_decode_str() {
- let s = [("\"\"", ""),
- ("\"foo\"", "foo"),
- ("\"\\\"\"", "\""),
- ("\"\\b\"", "\x08"),
- ("\"\\n\"", "\n"),
- ("\"\\r\"", "\r"),
- ("\"\\t\"", "\t"),
- ("\"\\u12ab\"", "\u{12ab}"),
- ("\"\\uAB12\"", "\u{AB12}")];
-
- for &(i, o) in s.iter() {
- let v: string::String = super::decode(i).unwrap();
- assert_eq!(v, o);
- }
- }
-
- #[test]
- fn test_read_array() {
- assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
- assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
- assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-
- assert_eq!(from_str("[]"), Ok(Array(vec![])));
- assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
- assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
- assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
- assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
- assert_eq!(from_str("[3, 1]"),
- Ok(Array(vec![U64(3), U64(1)])));
- assert_eq!(from_str("\n[3, 2]\n"),
- Ok(Array(vec![U64(3), U64(2)])));
- assert_eq!(from_str("[2, [4, 1]]"),
- Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
- }
-
- #[test]
- fn test_decode_array() {
- let v: Vec<()> = super::decode("[]").unwrap();
- assert_eq!(v, vec![]);
-
- let v: Vec<()> = super::decode("[null]").unwrap();
- assert_eq!(v, vec![()]);
-
- let v: Vec<bool> = super::decode("[true]").unwrap();
- assert_eq!(v, vec![true]);
-
- let v: Vec<int> = super::decode("[3, 1]").unwrap();
- assert_eq!(v, vec![3, 1]);
-
- let v: Vec<Vec<uint>> = super::decode("[[3], [1, 2]]").unwrap();
- assert_eq!(v, vec![vec![3], vec![1, 2]]);
- }
-
- #[test]
- fn test_decode_tuple() {
- let t: (uint, uint, uint) = super::decode("[1, 2, 3]").unwrap();
- assert_eq!(t, (1u, 2, 3));
-
- let t: (uint, string::String) = super::decode("[1, \"two\"]").unwrap();
- assert_eq!(t, (1u, "two".to_string()));
- }
-
- #[test]
- fn test_decode_tuple_malformed_types() {
- assert!(super::decode::<(uint, string::String)>("[1, 2]").is_err());
- }
-
- #[test]
- fn test_decode_tuple_malformed_length() {
- assert!(super::decode::<(uint, uint)>("[1, 2, 3]").is_err());
- }
-
- #[test]
- fn test_read_object() {
- assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
- assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
- assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
- assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
- assert_eq!(from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
- assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
- assert_eq!(from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
- assert_eq!(from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
- assert_eq!(from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
- assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
- assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
-
- assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
- assert_eq!(from_str("{\"a\": 3}").unwrap(),
- mk_object(&[("a".to_string(), U64(3))]));
-
- assert_eq!(from_str(
- "{ \"a\": null, \"b\" : true }").unwrap(),
- mk_object(&[
- ("a".to_string(), Null),
- ("b".to_string(), Boolean(true))]));
- assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
- mk_object(&[
- ("a".to_string(), Null),
- ("b".to_string(), Boolean(true))]));
- assert_eq!(from_str(
- "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
- mk_object(&[
- ("a".to_string(), F64(1.0)),
- ("b".to_string(), Array(vec![Boolean(true)]))
- ]));
- assert_eq!(from_str(
- "{\
- \"a\": 1.0, \
- \"b\": [\
- true,\
- \"foo\\nbar\", \
- { \"c\": {\"d\": null} } \
- ]\
- }").unwrap(),
- mk_object(&[
- ("a".to_string(), F64(1.0)),
- ("b".to_string(), Array(vec![
- Boolean(true),
- String("foo\nbar".to_string()),
- mk_object(&[
- ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
- ])
- ]))
- ]));
- }
-
- #[test]
- fn test_decode_struct() {
- let s = "{
- \"inner\": [
- { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
- ]
- }";
-
- let v: Outer = super::decode(s).unwrap();
- assert_eq!(
- v,
- Outer {
- inner: vec![
- Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
- ]
- }
- );
- }
-
- #[derive(RustcDecodable)]
- struct FloatStruct {
- f: f64,
- a: Vec<f64>
- }
- #[test]
- fn test_decode_struct_with_nan() {
- let s = "{\"f\":null,\"a\":[null,123]}";
- let obj: FloatStruct = super::decode(s).unwrap();
- assert!(obj.f.is_nan());
- assert!(obj.a[0].is_nan());
- assert_eq!(obj.a[1], 123f64);
- }
-
- #[test]
- fn test_decode_option() {
- let value: Option<string::String> = super::decode("null").unwrap();
- assert_eq!(value, None);
-
- let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
- assert_eq!(value, Some("jodhpurs".to_string()));
- }
-
- #[test]
- fn test_decode_enum() {
- let value: Animal = super::decode("\"Dog\"").unwrap();
- assert_eq!(value, Dog);
-
- let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
- let value: Animal = super::decode(s).unwrap();
- assert_eq!(value, Frog("Henry".to_string(), 349));
- }
-
- #[test]
- fn test_decode_map() {
- let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
- \"fields\":[\"Henry\", 349]}}";
- let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
-
- assert_eq!(map.remove(&"a".to_string()), Some(Dog));
- assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
- }
-
- #[test]
- fn test_multiline_errors() {
- assert_eq!(from_str("{\n \"foo\":\n \"bar\""),
- Err(SyntaxError(EOFWhileParsingObject, 3u, 8u)));
- }
-
- #[derive(RustcDecodable)]
- #[allow(dead_code)]
- struct DecodeStruct {
- x: f64,
- y: bool,
- z: string::String,
- w: Vec<DecodeStruct>
- }
- #[derive(RustcDecodable)]
- enum DecodeEnum {
- A(f64),
- B(string::String)
- }
- fn check_err<T: Decodable<Decoder, DecoderError>>(to_parse: &'static str,
- expected: DecoderError) {
- let res: DecodeResult<T> = match from_str(to_parse) {
- Err(e) => Err(ParseError(e)),
- Ok(json) => Decodable::decode(&mut Decoder::new(json))
- };
- match res {
- Ok(_) => panic!("`{}` parsed & decoded ok, expecting error `{}`",
- to_parse, expected),
- Err(ParseError(e)) => panic!("`{}` is not valid json: {}",
- to_parse, e),
- Err(e) => {
- assert_eq!(e, expected);
- }
- }
- }
- #[test]
- fn test_decode_errors_struct() {
- check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
- check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
- ExpectedError("Number".to_string(), "true".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
- ExpectedError("Boolean".to_string(), "[]".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
- ExpectedError("String".to_string(), "{}".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
- ExpectedError("Array".to_string(), "null".to_string()));
- check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
- MissingFieldError("w".to_string()));
- }
- #[test]
- fn test_decode_errors_enum() {
- check_err::<DecodeEnum>("{}",
- MissingFieldError("variant".to_string()));
- check_err::<DecodeEnum>("{\"variant\": 1}",
- ExpectedError("String".to_string(), "1".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"A\"}",
- MissingFieldError("fields".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
- ExpectedError("Array".to_string(), "null".to_string()));
- check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
- UnknownVariantError("C".to_string()));
- }
-
- #[test]
- fn test_find(){
- let json_value = from_str("{\"dog\" : \"cat\"}").unwrap();
- let found_str = json_value.find("dog");
- assert!(found_str.unwrap().as_string().unwrap() == "cat");
- }
-
- #[test]
- fn test_find_path(){
- let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
- let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
- assert!(found_str.unwrap().as_string().unwrap() == "cheese");
- }
-
- #[test]
- fn test_search(){
- let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
- let found_str = json_value.search("mouse").and_then(|j| j.as_string());
- assert!(found_str.unwrap() == "cheese");
- }
-
- #[test]
- fn test_index(){
- let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
- let ref array = json_value["animals"];
- assert_eq!(array[0].as_string().unwrap(), "dog");
- assert_eq!(array[1].as_string().unwrap(), "cat");
- assert_eq!(array[2].as_string().unwrap(), "mouse");
- }
-
- #[test]
- fn test_is_object(){
- let json_value = from_str("{}").unwrap();
- assert!(json_value.is_object());
- }
-
- #[test]
- fn test_as_object(){
- let json_value = from_str("{}").unwrap();
- let json_object = json_value.as_object();
- assert!(json_object.is_some());
- }
-
- #[test]
- fn test_is_array(){
- let json_value = from_str("[1, 2, 3]").unwrap();
- assert!(json_value.is_array());
- }
-
- #[test]
- fn test_as_array(){
- let json_value = from_str("[1, 2, 3]").unwrap();
- let json_array = json_value.as_array();
- let expected_length = 3;
- assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
- }
-
- #[test]
- fn test_is_string(){
- let json_value = from_str("\"dog\"").unwrap();
- assert!(json_value.is_string());
- }
-
- #[test]
- fn test_as_string(){
- let json_value = from_str("\"dog\"").unwrap();
- let json_str = json_value.as_string();
- let expected_str = "dog";
- assert_eq!(json_str, Some(expected_str));
- }
-
- #[test]
- fn test_is_number(){
- let json_value = from_str("12").unwrap();
- assert!(json_value.is_number());
- }
-
- #[test]
- fn test_is_i64(){
- let json_value = from_str("-12").unwrap();
- assert!(json_value.is_i64());
-
- let json_value = from_str("12").unwrap();
- assert!(!json_value.is_i64());
-
- let json_value = from_str("12.0").unwrap();
- assert!(!json_value.is_i64());
- }
-
- #[test]
- fn test_is_u64(){
- let json_value = from_str("12").unwrap();
- assert!(json_value.is_u64());
-
- let json_value = from_str("-12").unwrap();
- assert!(!json_value.is_u64());
-
- let json_value = from_str("12.0").unwrap();
- assert!(!json_value.is_u64());
- }
-
- #[test]
- fn test_is_f64(){
- let json_value = from_str("12").unwrap();
- assert!(!json_value.is_f64());
-
- let json_value = from_str("-12").unwrap();
- assert!(!json_value.is_f64());
-
- let json_value = from_str("12.0").unwrap();
- assert!(json_value.is_f64());
-
- let json_value = from_str("-12.0").unwrap();
- assert!(json_value.is_f64());
- }
-
- #[test]
- fn test_as_i64(){
- let json_value = from_str("-12").unwrap();
- let json_num = json_value.as_i64();
- assert_eq!(json_num, Some(-12));
- }
-
- #[test]
- fn test_as_u64(){
- let json_value = from_str("12").unwrap();
- let json_num = json_value.as_u64();
- assert_eq!(json_num, Some(12));
- }
-
- #[test]
- fn test_as_f64(){
- let json_value = from_str("12.0").unwrap();
- let json_num = json_value.as_f64();
- assert_eq!(json_num, Some(12f64));
- }
-
- #[test]
- fn test_is_boolean(){
- let json_value = from_str("false").unwrap();
- assert!(json_value.is_boolean());
- }
-
- #[test]
- fn test_as_boolean(){
- let json_value = from_str("false").unwrap();
- let json_bool = json_value.as_boolean();
- let expected_bool = false;
- assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
- }
-
- #[test]
- fn test_is_null(){
- let json_value = from_str("null").unwrap();
- assert!(json_value.is_null());
- }
-
- #[test]
- fn test_as_null(){
- let json_value = from_str("null").unwrap();
- let json_null = json_value.as_null();
- let expected_null = ();
- assert!(json_null.is_some() && json_null.unwrap() == expected_null);
- }
-
- #[test]
- fn test_encode_hashmap_with_numeric_key() {
- use std::str::from_utf8;
- use std::io::Writer;
- use std::collections::HashMap;
- let mut hm: HashMap<uint, bool> = HashMap::new();
- hm.insert(1, true);
- let mut mem_buf = Vec::new();
- write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
- let json_str = from_utf8(mem_buf[]).unwrap();
- match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- _ => {} // it parsed and we are good to go
- }
- }
-
- #[test]
- fn test_prettyencode_hashmap_with_numeric_key() {
- use std::str::from_utf8;
- use std::io::Writer;
- use std::collections::HashMap;
- let mut hm: HashMap<uint, bool> = HashMap::new();
- hm.insert(1, true);
- let mut mem_buf = Vec::new();
- write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
- let json_str = from_utf8(mem_buf[]).unwrap();
- match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- _ => {} // it parsed and we are good to go
- }
- }
-
- #[test]
- fn test_prettyencoder_indent_level_param() {
- use std::str::from_utf8;
- use std::collections::BTreeMap;
-
- let mut tree = BTreeMap::new();
-
- tree.insert("hello".to_string(), String("guten tag".to_string()));
- tree.insert("goodbye".to_string(), String("sayonara".to_string()));
-
- let json = Array(
- // The following layout below should look a lot like
- // the pretty-printed JSON (indent * x)
- vec!
- ( // 0x
- String("greetings".to_string()), // 1x
- Object(tree), // 1x + 2x + 2x + 1x
- ) // 0x
- // End JSON array (7 lines)
- );
-
- // Helper function for counting indents
- fn indents(source: &str) -> uint {
- let trimmed = source.trim_left_matches(' ');
- source.len() - trimmed.len()
- }
-
- // Test up to 4 spaces of indents (more?)
- for i in range(0, 4u) {
- let mut writer = Vec::new();
- write!(&mut writer, "{}",
- super::as_pretty_json(&json).indent(i)).unwrap();
-
- let printed = from_utf8(writer[]).unwrap();
-
- // Check for indents at each line
- let lines: Vec<&str> = printed.lines().collect();
- assert_eq!(lines.len(), 7); // JSON should be 7 lines
-
- assert_eq!(indents(lines[0]), 0 * i); // [
- assert_eq!(indents(lines[1]), 1 * i); // "greetings",
- assert_eq!(indents(lines[2]), 1 * i); // {
- assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag",
- assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara"
- assert_eq!(indents(lines[5]), 1 * i); // },
- assert_eq!(indents(lines[6]), 0 * i); // ]
-
- // Finally, test that the pretty-printed JSON is valid
- from_str(printed).ok().expect("Pretty-printed JSON is invalid!");
- }
- }
-
- #[test]
- fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
- use std::collections::HashMap;
- use Decodable;
- let json_str = "{\"1\":true}";
- let json_obj = match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- Ok(o) => o
- };
- let mut decoder = Decoder::new(json_obj);
- let _hm: HashMap<uint, bool> = Decodable::decode(&mut decoder).unwrap();
- }
-
- #[test]
- fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
- use std::collections::HashMap;
- use Decodable;
- let json_str = "{\"a\":true}";
- let json_obj = match from_str(json_str) {
- Err(_) => panic!("Unable to parse json_str: {}", json_str),
- Ok(o) => o
- };
- let mut decoder = Decoder::new(json_obj);
- let result: Result<HashMap<uint, bool>, DecoderError> = Decodable::decode(&mut decoder);
- assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
- }
-
- fn assert_stream_equal(src: &str,
- expected: Vec<(JsonEvent, Vec<StackElement>)>) {
- let mut parser = Parser::new(src.chars());
- let mut i = 0;
- loop {
- let evt = match parser.next() {
- Some(e) => e,
- None => { break; }
- };
- let (ref expected_evt, ref expected_stack) = expected[i];
- if !parser.stack().is_equal_to(expected_stack.as_slice()) {
- panic!("Parser stack is not equal to {}", expected_stack);
- }
- assert_eq!(&evt, expected_evt);
- i+=1;
- }
- }
- #[test]
- #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
- fn test_streaming_parser() {
- assert_stream_equal(
- r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
- vec![
- (ObjectStart, vec![]),
- (StringValue("bar".to_string()), vec![Key("foo")]),
- (ArrayStart, vec![Key("array")]),
- (U64Value(0), vec![Key("array"), Index(0)]),
- (U64Value(1), vec![Key("array"), Index(1)]),
- (U64Value(2), vec![Key("array"), Index(2)]),
- (U64Value(3), vec![Key("array"), Index(3)]),
- (U64Value(4), vec![Key("array"), Index(4)]),
- (U64Value(5), vec![Key("array"), Index(5)]),
- (ArrayEnd, vec![Key("array")]),
- (ArrayStart, vec![Key("idents")]),
- (NullValue, vec![Key("idents"), Index(0)]),
- (BooleanValue(true), vec![Key("idents"), Index(1)]),
- (BooleanValue(false), vec![Key("idents"), Index(2)]),
- (ArrayEnd, vec![Key("idents")]),
- (ObjectEnd, vec![]),
- ]
- );
- }
- fn last_event(src: &str) -> JsonEvent {
- let mut parser = Parser::new(src.chars());
- let mut evt = NullValue;
- loop {
- evt = match parser.next() {
- Some(e) => e,
- None => return evt,
- }
- }
- }
-
- #[test]
- #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
- fn test_read_object_streaming() {
- assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
- assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2)));
- assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
- assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
- assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
- assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6)));
- assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6)));
- assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
- assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8)));
- assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
- assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
-
- assert_stream_equal(
- "{}",
- vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
- );
- assert_stream_equal(
- "{\"a\": 3}",
- vec![
- (ObjectStart, vec![]),
- (U64Value(3), vec![Key("a")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "{ \"a\": null, \"b\" : true }",
- vec![
- (ObjectStart, vec![]),
- (NullValue, vec![Key("a")]),
- (BooleanValue(true), vec![Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "{\"a\" : 1.0 ,\"b\": [ true ]}",
- vec![
- (ObjectStart, vec![]),
- (F64Value(1.0), vec![Key("a")]),
- (ArrayStart, vec![Key("b")]),
- (BooleanValue(true),vec![Key("b"), Index(0)]),
- (ArrayEnd, vec![Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- assert_stream_equal(
- r#"{
- "a": 1.0,
- "b": [
- true,
- "foo\nbar",
- { "c": {"d": null} }
- ]
- }"#,
- vec![
- (ObjectStart, vec![]),
- (F64Value(1.0), vec![Key("a")]),
- (ArrayStart, vec![Key("b")]),
- (BooleanValue(true), vec![Key("b"), Index(0)]),
- (StringValue("foo\nbar".to_string()), vec![Key("b"), Index(1)]),
- (ObjectStart, vec![Key("b"), Index(2)]),
- (ObjectStart, vec![Key("b"), Index(2), Key("c")]),
- (NullValue, vec![Key("b"), Index(2), Key("c"), Key("d")]),
- (ObjectEnd, vec![Key("b"), Index(2), Key("c")]),
- (ObjectEnd, vec![Key("b"), Index(2)]),
- (ArrayEnd, vec![Key("b")]),
- (ObjectEnd, vec![]),
- ]
- );
- }
- #[test]
- #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
- fn test_read_array_streaming() {
- assert_stream_equal(
- "[]",
- vec![
- (ArrayStart, vec![]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[ ]",
- vec![
- (ArrayStart, vec![]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[true]",
- vec![
- (ArrayStart, vec![]),
- (BooleanValue(true), vec![Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[ false ]",
- vec![
- (ArrayStart, vec![]),
- (BooleanValue(false), vec![Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[null]",
- vec![
- (ArrayStart, vec![]),
- (NullValue, vec![Index(0)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[3, 1]",
- vec![
- (ArrayStart, vec![]),
- (U64Value(3), vec![Index(0)]),
- (U64Value(1), vec![Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "\n[3, 2]\n",
- vec![
- (ArrayStart, vec![]),
- (U64Value(3), vec![Index(0)]),
- (U64Value(2), vec![Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
- assert_stream_equal(
- "[2, [4, 1]]",
- vec![
- (ArrayStart, vec![]),
- (U64Value(2), vec![Index(0)]),
- (ArrayStart, vec![Index(1)]),
- (U64Value(4), vec![Index(1), Index(0)]),
- (U64Value(1), vec![Index(1), Index(1)]),
- (ArrayEnd, vec![Index(1)]),
- (ArrayEnd, vec![]),
- ]
- );
-
- assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2)));
-
- assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
- assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
- assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
- assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-
- }
- #[test]
- fn test_trailing_characters_streaming() {
- assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5)));
- assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
- assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2)));
- assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
- assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3)));
- }
- #[test]
- fn test_read_identifiers_streaming() {
- assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
- assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
- assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
-
- assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
- assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2)));
- assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3)));
- }
-
- #[test]
- fn test_stack() {
- let mut stack = Stack::new();
-
- assert!(stack.is_empty());
- assert!(stack.len() == 0);
- assert!(!stack.last_is_index());
-
- stack.push_index(0);
- stack.bump_index();
-
- assert!(stack.len() == 1);
- assert!(stack.is_equal_to(&[Index(1)]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1)]));
- assert!(stack.last_is_index());
- assert!(stack.get(0) == Index(1));
-
- stack.push_key("foo".to_string());
-
- assert!(stack.len() == 2);
- assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1), Key("foo")]));
- assert!(stack.ends_with(&[Key("foo")]));
- assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
-
- stack.push_key("bar".to_string());
-
- assert!(stack.len() == 3);
- assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")]));
- assert!(stack.ends_with(&[Key("bar")]));
- assert!(stack.ends_with(&[Key("foo"), Key("bar")]));
- assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")]));
- assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
- assert!(stack.get(2) == Key("bar"));
-
- stack.pop();
-
- assert!(stack.len() == 2);
- assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1), Key("foo")]));
- assert!(stack.starts_with(&[Index(1)]));
- assert!(stack.ends_with(&[Index(1), Key("foo")]));
- assert!(stack.ends_with(&[Key("foo")]));
- assert!(!stack.last_is_index());
- assert!(stack.get(0) == Index(1));
- assert!(stack.get(1) == Key("foo"));
- }
-
- #[test]
- fn test_to_json() {
- use std::collections::{HashMap,BTreeMap};
- use super::ToJson;
-
- let array2 = Array(vec!(U64(1), U64(2)));
- let array3 = Array(vec!(U64(1), U64(2), U64(3)));
- let object = {
- let mut tree_map = BTreeMap::new();
- tree_map.insert("a".to_string(), U64(1));
- tree_map.insert("b".to_string(), U64(2));
- Object(tree_map)
- };
-
- assert_eq!(array2.to_json(), array2);
- assert_eq!(object.to_json(), object);
- assert_eq!(3_i.to_json(), I64(3));
- assert_eq!(4_i8.to_json(), I64(4));
- assert_eq!(5_i16.to_json(), I64(5));
- assert_eq!(6_i32.to_json(), I64(6));
- assert_eq!(7_i64.to_json(), I64(7));
- assert_eq!(8_u.to_json(), U64(8));
- assert_eq!(9_u8.to_json(), U64(9));
- assert_eq!(10_u16.to_json(), U64(10));
- assert_eq!(11_u32.to_json(), U64(11));
- assert_eq!(12_u64.to_json(), U64(12));
- assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
- assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
- assert_eq!(().to_json(), Null);
- assert_eq!(f32::INFINITY.to_json(), Null);
- assert_eq!(f64::NAN.to_json(), Null);
- assert_eq!(true.to_json(), Boolean(true));
- assert_eq!(false.to_json(), Boolean(false));
- assert_eq!("abc".to_json(), String("abc".to_string()));
- assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
- assert_eq!((1u, 2u).to_json(), array2);
- assert_eq!((1u, 2u, 3u).to_json(), array3);
- assert_eq!([1u, 2].to_json(), array2);
- assert_eq!((&[1u, 2, 3]).to_json(), array3);
- assert_eq!((vec![1u, 2]).to_json(), array2);
- assert_eq!(vec!(1u, 2, 3).to_json(), array3);
- let mut tree_map = BTreeMap::new();
- tree_map.insert("a".to_string(), 1u);
- tree_map.insert("b".to_string(), 2);
- assert_eq!(tree_map.to_json(), object);
- let mut hash_map = HashMap::new();
- hash_map.insert("a".to_string(), 1u);
- hash_map.insert("b".to_string(), 2);
- assert_eq!(hash_map.to_json(), object);
- assert_eq!(Some(15i).to_json(), I64(15));
- assert_eq!(Some(15u).to_json(), U64(15));
- assert_eq!(None::<int>.to_json(), Null);
- }
-
- #[bench]
- fn bench_streaming_small(b: &mut Bencher) {
- b.iter( || {
- let mut parser = Parser::new(
- r#"{
- "a": 1.0,
- "b": [
- true,
- "foo\nbar",
- { "c": {"d": null} }
- ]
- }"#.chars()
- );
- loop {
- match parser.next() {
- None => return,
- _ => {}
- }
- }
- });
- }
- #[bench]
- fn bench_small(b: &mut Bencher) {
- b.iter( || {
- let _ = from_str(r#"{
- "a": 1.0,
- "b": [
- true,
- "foo\nbar",
- { "c": {"d": null} }
- ]
- }"#);
- });
- }
-
- fn big_json() -> string::String {
- let mut src = "[\n".to_string();
- for _ in range(0i, 500) {
- src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
- [1,2,3]},"#);
- }
- src.push_str("{}]");
- return src;
- }
-
- #[bench]
- fn bench_streaming_large(b: &mut Bencher) {
- let src = big_json();
- b.iter( || {
- let mut parser = Parser::new(src.chars());
- loop {
- match parser.next() {
- None => return,
- _ => {}
- }
- }
- });
- }
- #[bench]
- fn bench_large(b: &mut Bencher) {
- let src = big_json();
- b.iter( || { let _ = from_str(src.as_slice()); });
- }
-}
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
-#![feature(macro_rules, default_type_params, phase, slicing_syntax, globs)]
-#![feature(unboxed_closures)]
-#![feature(associated_types)]
+#![feature(slicing_syntax)]
+#![feature(old_impl_check)]
+#![cfg_attr(stage0, allow(unused_attributes))]
// test harness access
-#[cfg(test)]
-extern crate test;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
+#[cfg(test)] extern crate test;
+#[macro_use] extern crate log;
extern crate unicode;
-
extern crate collections;
pub use self::serialize::{Decoder, Encoder, Decodable, Encodable,
DecoderHelpers, EncoderHelpers};
-#[cfg(stage0)]
-#[path = "serialize_stage0.rs"]
-mod serialize;
-#[cfg(not(stage0))]
mod serialize;
-
-#[cfg(stage0)]
-#[path = "collection_impls_stage0.rs"]
-mod collection_impls;
-#[cfg(not(stage0))]
mod collection_impls;
pub mod base64;
pub mod hex;
-
-#[cfg(stage0)]
-#[path = "json_stage0.rs"]
-pub mod json;
-#[cfg(not(stage0))]
pub mod json;
mod rustc_serialize {
impl Encodable for String {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_str(self[])
+ s.emit_str(self.index(&FullRange))
}
}
/// Evaluates to the number of identifiers passed to it, for example: `count_idents!(a, b, c) == 3
macro_rules! count_idents {
() => { 0u };
- ($_i:ident $(, $rest:ident)*) => { 1 + count_idents!($($rest),*) }
+ ($_i:ident, $($rest:ident,)*) => { 1 + count_idents!($($rest,)*) }
}
macro_rules! tuple {
impl<$($name:Decodable),*> Decodable for ($($name,)*) {
#[allow(non_snake_case)]
fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
- let len: uint = count_idents!($($name),*);
+ let len: uint = count_idents!($($name,)*);
d.read_tuple(len, |d| {
let mut i = 0;
let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 },
pub trait EncoderHelpers: Encoder {
fn emit_from_vec<T, F>(&mut self, v: &[T], f: F)
- -> Result<(), <Self as Encoder>::Error>
- where F: FnMut(&mut Self, &T) -> Result<(), <Self as Encoder>::Error>;
+ -> Result<(), Self::Error>
+ where F: FnMut(&mut Self, &T) -> Result<(), Self::Error>;
}
impl<S:Encoder> EncoderHelpers for S {
pub trait DecoderHelpers: Decoder {
fn read_to_vec<T, F>(&mut self, f: F)
- -> Result<Vec<T>, <Self as Decoder>::Error> where
- F: FnMut(&mut Self) -> Result<T, <Self as Decoder>::Error>;
+ -> Result<Vec<T>, Self::Error> where
+ F: FnMut(&mut Self) -> Result<T, Self::Error>;
}
impl<D: Decoder> DecoderHelpers for D {
+++ /dev/null
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support code for encoding and decoding types.
-
-/*
-Core encoding and decoding interfaces.
-*/
-
-use std::path;
-use std::rc::Rc;
-use std::cell::{Cell, RefCell};
-use std::sync::Arc;
-
-pub trait Encoder<E> {
- // Primitive types:
- fn emit_nil(&mut self) -> Result<(), E>;
- fn emit_uint(&mut self, v: uint) -> Result<(), E>;
- fn emit_u64(&mut self, v: u64) -> Result<(), E>;
- fn emit_u32(&mut self, v: u32) -> Result<(), E>;
- fn emit_u16(&mut self, v: u16) -> Result<(), E>;
- fn emit_u8(&mut self, v: u8) -> Result<(), E>;
- fn emit_int(&mut self, v: int) -> Result<(), E>;
- fn emit_i64(&mut self, v: i64) -> Result<(), E>;
- fn emit_i32(&mut self, v: i32) -> Result<(), E>;
- fn emit_i16(&mut self, v: i16) -> Result<(), E>;
- fn emit_i8(&mut self, v: i8) -> Result<(), E>;
- fn emit_bool(&mut self, v: bool) -> Result<(), E>;
- fn emit_f64(&mut self, v: f64) -> Result<(), E>;
- fn emit_f32(&mut self, v: f32) -> Result<(), E>;
- fn emit_char(&mut self, v: char) -> Result<(), E>;
- fn emit_str(&mut self, v: &str) -> Result<(), E>;
-
- // Compound types:
- fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- fn emit_enum_variant<F>(&mut self, v_name: &str,
- v_id: uint,
- len: uint,
- f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
- v_id: uint,
- len: uint,
- f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_enum_struct_variant_field<F>(&mut self,
- f_name: &str,
- f_idx: uint,
- f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- fn emit_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- // Specialized types:
- fn emit_option<F>(&mut self, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_option_none(&mut self) -> Result<(), E>;
- fn emit_option_some<F>(&mut self, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- fn emit_seq<F>(&mut self, len: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-
- fn emit_map<F>(&mut self, len: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
- fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
- F: FnMut(&mut Self) -> Result<(), E>;
- fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> Result<(), E> where
- F: FnOnce(&mut Self) -> Result<(), E>;
-}
-
-pub trait Decoder<E> {
- // Primitive types:
- fn read_nil(&mut self) -> Result<(), E>;
- fn read_uint(&mut self) -> Result<uint, E>;
- fn read_u64(&mut self) -> Result<u64, E>;
- fn read_u32(&mut self) -> Result<u32, E>;
- fn read_u16(&mut self) -> Result<u16, E>;
- fn read_u8(&mut self) -> Result<u8, E>;
- fn read_int(&mut self) -> Result<int, E>;
- fn read_i64(&mut self) -> Result<i64, E>;
- fn read_i32(&mut self) -> Result<i32, E>;
- fn read_i16(&mut self) -> Result<i16, E>;
- fn read_i8(&mut self) -> Result<i8, E>;
- fn read_bool(&mut self) -> Result<bool, E>;
- fn read_f64(&mut self) -> Result<f64, E>;
- fn read_f32(&mut self) -> Result<f32, E>;
- fn read_char(&mut self) -> Result<char, E>;
- fn read_str(&mut self) -> Result<String, E>;
-
- // Compound types:
- fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
- F: FnMut(&mut Self, uint) -> Result<T, E>;
- fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, E> where
- F: FnMut(&mut Self, uint) -> Result<T, E>;
- fn read_enum_struct_variant_field<T, F>(&mut self,
- &f_name: &str,
- f_idx: uint,
- f: F)
- -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
- fn read_struct_field<T, F>(&mut self,
- f_name: &str,
- f_idx: uint,
- f: F)
- -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- fn read_tuple<T, F>(&mut self, len: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
- fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
- fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- // Specialized types:
- fn read_option<T, F>(&mut self, f: F) -> Result<T, E> where
- F: FnMut(&mut Self, bool) -> Result<T, E>;
-
- fn read_seq<T, F>(&mut self, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self, uint) -> Result<T, E>;
- fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- fn read_map<T, F>(&mut self, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self, uint) -> Result<T, E>;
- fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
- fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> Result<T, E> where
- F: FnOnce(&mut Self) -> Result<T, E>;
-
- // Failure
- fn error(&mut self, err: &str) -> E;
-}
-
-pub trait Encodable<S:Encoder<E>, E> {
- fn encode(&self, s: &mut S) -> Result<(), E>;
-}
-
-pub trait Decodable<D:Decoder<E>, E> {
- fn decode(d: &mut D) -> Result<Self, E>;
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for uint {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_uint(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for uint {
- fn decode(d: &mut D) -> Result<uint, E> {
- d.read_uint()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for u8 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_u8(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for u8 {
- fn decode(d: &mut D) -> Result<u8, E> {
- d.read_u8()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for u16 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_u16(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for u16 {
- fn decode(d: &mut D) -> Result<u16, E> {
- d.read_u16()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for u32 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_u32(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for u32 {
- fn decode(d: &mut D) -> Result<u32, E> {
- d.read_u32()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for u64 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_u64(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for u64 {
- fn decode(d: &mut D) -> Result<u64, E> {
- d.read_u64()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for int {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_int(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for int {
- fn decode(d: &mut D) -> Result<int, E> {
- d.read_int()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for i8 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_i8(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for i8 {
- fn decode(d: &mut D) -> Result<i8, E> {
- d.read_i8()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for i16 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_i16(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for i16 {
- fn decode(d: &mut D) -> Result<i16, E> {
- d.read_i16()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for i32 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_i32(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for i32 {
- fn decode(d: &mut D) -> Result<i32, E> {
- d.read_i32()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for i64 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_i64(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for i64 {
- fn decode(d: &mut D) -> Result<i64, E> {
- d.read_i64()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for str {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_str(self)
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for String {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_str(self[])
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for String {
- fn decode(d: &mut D) -> Result<String, E> {
- d.read_str()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for f32 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_f32(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for f32 {
- fn decode(d: &mut D) -> Result<f32, E> {
- d.read_f32()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for f64 {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_f64(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for f64 {
- fn decode(d: &mut D) -> Result<f64, E> {
- d.read_f64()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for bool {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_bool(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for bool {
- fn decode(d: &mut D) -> Result<bool, E> {
- d.read_bool()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for char {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_char(*self)
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for char {
- fn decode(d: &mut D) -> Result<char, E> {
- d.read_char()
- }
-}
-
-impl<E, S:Encoder<E>> Encodable<S, E> for () {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_nil()
- }
-}
-
-impl<E, D:Decoder<E>> Decodable<D, E> for () {
- fn decode(d: &mut D) -> Result<(), E> {
- d.read_nil()
- }
-}
-
-impl<'a, E, S: Encoder<E>, T: ?Sized + Encodable<S, E>> Encodable<S, E> for &'a T {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- (**self).encode(s)
- }
-}
-
-impl<E, S: Encoder<E>, T: ?Sized + Encodable<S, E>> Encodable<S, E> for Box<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- (**self).encode(s)
- }
-}
-
-impl<E, D:Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for Box<T> {
- fn decode(d: &mut D) -> Result<Box<T>, E> {
- Ok(box try!(Decodable::decode(d)))
- }
-}
-
-impl<E, D:Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for Box<[T]> {
- fn decode(d: &mut D) -> Result<Box<[T]>, E> {
- let v: Vec<T> = try!(Decodable::decode(d));
- Ok(v.into_boxed_slice())
- }
-}
-
-impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Rc<T> {
- #[inline]
- fn encode(&self, s: &mut S) -> Result<(), E> {
- (**self).encode(s)
- }
-}
-
-impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Rc<T> {
- #[inline]
- fn decode(d: &mut D) -> Result<Rc<T>, E> {
- Ok(Rc::new(try!(Decodable::decode(d))))
- }
-}
-
-impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for [T] {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)))
- }
- Ok(())
- })
- }
-}
-
-impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Vec<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_seq(self.len(), |s| {
- for (i, e) in self.iter().enumerate() {
- try!(s.emit_seq_elt(i, |s| e.encode(s)))
- }
- Ok(())
- })
- }
-}
-
-impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Vec<T> {
- fn decode(d: &mut D) -> Result<Vec<T>, E> {
- d.read_seq(|d, len| {
- let mut v = Vec::with_capacity(len);
- for i in range(0, len) {
- v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
- }
- Ok(v)
- })
- }
-}
-
-impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Option<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_option(|s| {
- match *self {
- None => s.emit_option_none(),
- Some(ref v) => s.emit_option_some(|s| v.encode(s)),
- }
- })
- }
-}
-
-impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Option<T> {
- fn decode(d: &mut D) -> Result<Option<T>, E> {
- d.read_option(|d, b| {
- if b {
- Ok(Some(try!(Decodable::decode(d))))
- } else {
- Ok(None)
- }
- })
- }
-}
-
-macro_rules! peel {
- ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
-}
-
-/// Evaluates to the number of identifiers passed to it, for example: `count_idents!(a, b, c) == 3
-macro_rules! count_idents {
- () => { 0u };
- ($_i:ident $(, $rest:ident)*) => { 1 + count_idents!($($rest),*) }
-}
-
-macro_rules! tuple {
- () => ();
- ( $($name:ident,)+ ) => (
- impl<E, D:Decoder<E>,$($name:Decodable<D, E>),*> Decodable<D,E> for ($($name,)*) {
- #[allow(non_snake_case)]
- fn decode(d: &mut D) -> Result<($($name,)*), E> {
- let len: uint = count_idents!($($name),*);
- d.read_tuple(len, |d| {
- let mut i = 0;
- let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name,E> {
- Decodable::decode(d)
- })),)*);
- return Ok(ret);
- })
- }
- }
- impl<E, S:Encoder<E>,$($name:Encodable<S, E>),*> Encodable<S, E> for ($($name,)*) {
- #[allow(non_snake_case)]
- fn encode(&self, s: &mut S) -> Result<(), E> {
- let ($(ref $name,)*) = *self;
- let mut n = 0;
- $(let $name = $name; n += 1;)*
- s.emit_tuple(n, |s| {
- let mut i = 0;
- $(try!(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s)));)*
- Ok(())
- })
- }
- }
- peel! { $($name,)* }
- )
-}
-
-tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
-
-impl<E, S: Encoder<E>> Encodable<S, E> for path::posix::Path {
- fn encode(&self, e: &mut S) -> Result<(), E> {
- self.as_vec().encode(e)
- }
-}
-
-impl<E, D: Decoder<E>> Decodable<D, E> for path::posix::Path {
- fn decode(d: &mut D) -> Result<path::posix::Path, E> {
- let bytes: Vec<u8> = try!(Decodable::decode(d));
- Ok(path::posix::Path::new(bytes))
- }
-}
-
-impl<E, S: Encoder<E>> Encodable<S, E> for path::windows::Path {
- fn encode(&self, e: &mut S) -> Result<(), E> {
- self.as_vec().encode(e)
- }
-}
-
-impl<E, D: Decoder<E>> Decodable<D, E> for path::windows::Path {
- fn decode(d: &mut D) -> Result<path::windows::Path, E> {
- let bytes: Vec<u8> = try!(Decodable::decode(d));
- Ok(path::windows::Path::new(bytes))
- }
-}
-
-impl<E, S: Encoder<E>, T: Encodable<S, E> + Copy> Encodable<S, E> for Cell<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- self.get().encode(s)
- }
-}
-
-impl<E, D: Decoder<E>, T: Decodable<D, E> + Copy> Decodable<D, E> for Cell<T> {
- fn decode(d: &mut D) -> Result<Cell<T>, E> {
- Ok(Cell::new(try!(Decodable::decode(d))))
- }
-}
-
-// FIXME: #15036
-// Should use `try_borrow`, returning a
-// `encoder.error("attempting to Encode borrowed RefCell")`
-// from `encode` when `try_borrow` returns `None`.
-
-impl<E, S: Encoder<E>, T: Encodable<S, E>> Encodable<S, E> for RefCell<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- self.borrow().encode(s)
- }
-}
-
-impl<E, D: Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for RefCell<T> {
- fn decode(d: &mut D) -> Result<RefCell<T>, E> {
- Ok(RefCell::new(try!(Decodable::decode(d))))
- }
-}
-
-impl<E, S:Encoder<E>, T:Encodable<S, E>> Encodable<S, E> for Arc<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- (**self).encode(s)
- }
-}
-
-impl<E, D:Decoder<E>,T:Decodable<D, E>+Send+Sync> Decodable<D, E> for Arc<T> {
- fn decode(d: &mut D) -> Result<Arc<T>, E> {
- Ok(Arc::new(try!(Decodable::decode(d))))
- }
-}
-
-// ___________________________________________________________________________
-// Helper routines
-
-pub trait EncoderHelpers<E> {
- fn emit_from_vec<T, F>(&mut self, v: &[T], f: F) -> Result<(), E> where
- F: FnMut(&mut Self, &T) -> Result<(), E>;
-}
-
-impl<E, S:Encoder<E>> EncoderHelpers<E> for S {
- fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), E> where
- F: FnMut(&mut S, &T) -> Result<(), E>,
- {
- self.emit_seq(v.len(), |this| {
- for (i, e) in v.iter().enumerate() {
- try!(this.emit_seq_elt(i, |this| {
- f(this, e)
- }));
- }
- Ok(())
- })
- }
-}
-
-pub trait DecoderHelpers<E> {
- fn read_to_vec<T, F>(&mut self, f: F) -> Result<Vec<T>, E> where
- F: FnMut(&mut Self) -> Result<T, E>;
-}
-
-impl<E, D:Decoder<E>> DecoderHelpers<E> for D {
- fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, E> where F:
- FnMut(&mut D) -> Result<T, E>,
- {
- self.read_seq(|this, len| {
- let mut v = Vec::with_capacity(len);
- for i in range(0, len) {
- v.push(try!(this.read_seq_elt(i, |this| f(this))));
- }
- Ok(v)
- })
- }
-}
/// let mut flags = FLAG_A | FLAG_B;
/// flags.clear();
/// assert!(flags.is_empty());
-/// assert_eq!(format!("{}", flags).as_slice(), "hi!");
+/// assert_eq!(format!("{:?}", flags).as_slice(), "hi!");
/// }
/// ```
///
use self::SearchResult::*;
use self::VacantEntryState::*;
-use borrow::{BorrowFrom, ToOwned};
+use borrow::BorrowFrom;
use clone::Clone;
use cmp::{max, Eq, PartialEq};
use default::Default;
use fmt::{self, Show};
use hash::{Hash, Hasher, RandomSipHasher};
use iter::{self, Iterator, IteratorExt, FromIterator, Extend, Map};
-use kinds::Sized;
+use marker::Sized;
use mem::{self, replace};
use num::{Int, UnsignedInt};
use ops::{Deref, FnMut, Index, IndexMut};
///
/// // Use derived implementation to print the status of the vikings.
/// for (viking, health) in vikings.iter() {
-/// println!("{} has {} hp", viking, health);
+/// println!("{:?} has {} hp", viking, health);
/// }
/// ```
#[derive(Clone)]
}
}
+#[old_impl_check]
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
fn make_hash<X: ?Sized + Hash<S>>(&self, x: &X) -> SafeHash {
table::make_hash(&self.hasher, x)
}
}
+#[old_impl_check]
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
/// Creates an empty hashmap which will use the given hasher to hash keys.
///
}
}
- #[stable]
/// Gets the given key's corresponding entry in the map for in-place manipulation.
- /// Regardless of whether or not `to_owned()` has been called, the key must hash the same way.
- pub fn entry<'a, Q: ?Sized>(&'a mut self, key: &'a Q) -> Entry<'a, Q, K, V>
- where Q: Eq + Hash<S> + ToOwned<K>
+ #[unstable = "precise API still being fleshed out"]
+ pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V>
{
// Gotta resize now.
self.reserve(1);
- let hash = self.make_hash(key);
+ let hash = self.make_hash(&key);
search_entry_hashed(&mut self.table, hash, key)
}
}
}
-fn search_entry_hashed<'a, K, V, Q: ?Sized>(table: &'a mut RawTable<K,V>, hash: SafeHash, k: &'a Q)
- -> Entry<'a, Q, K, V>
- where Q: Eq + ToOwned<K>
+fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable<K,V>, hash: SafeHash, k: K)
+ -> Entry<'a, K, V>
{
// Worst case, we'll find one empty bucket among `size + 1` buckets.
let size = table.size();
// hash matches?
if bucket.hash() == hash {
// key matches?
- if *k == *BorrowFrom::borrow_from(bucket.read().0) {
+ if k == *bucket.read().0 {
return Occupied(OccupiedEntry{
elem: bucket,
});
}
#[stable]
+#[old_impl_check]
impl<K: Eq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> {
fn eq(&self, other: &HashMap<K, V, H>) -> bool {
if self.len() != other.len() { return false; }
}
#[stable]
+#[old_impl_check]
impl<K: Eq + Hash<S>, V: Eq, S, H: Hasher<S>> Eq for HashMap<K, V, H> {}
#[stable]
+#[old_impl_check]
impl<K: Eq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
+ try!(write!(f, "HashMap {{"));
for (i, (k, v)) in self.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{}: {}", *k, *v));
+ try!(write!(f, "{:?}: {:?}", *k, *v));
}
write!(f, "}}")
}
#[stable]
+#[old_impl_check]
impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H> {
#[stable]
fn default() -> HashMap<K, V, H> {
}
#[stable]
+#[old_impl_check]
impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V, H>
where Q: BorrowFrom<K> + Hash<S> + Eq
{
}
#[stable]
+#[old_impl_check]
impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> IndexMut<Q> for HashMap<K, V, H>
where Q: BorrowFrom<K> + Hash<S> + Eq
{
>
}
-#[stable]
/// A view into a single occupied location in a HashMap
+#[unstable = "precise API still being fleshed out"]
pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
elem: FullBucket<K, V, &'a mut RawTable<K, V>>,
}
-#[stable]
/// A view into a single empty location in a HashMap
-pub struct VacantEntry<'a, Q: ?Sized + 'a, K: 'a, V: 'a> {
+#[unstable = "precise API still being fleshed out"]
+pub struct VacantEntry<'a, K: 'a, V: 'a> {
hash: SafeHash,
- key: &'a Q,
+ key: K,
elem: VacantEntryState<K, V, &'a mut RawTable<K, V>>,
}
-#[stable]
/// A view into a single location in a map, which may be vacant or occupied
-pub enum Entry<'a, Q: ?Sized + 'a, K: 'a, V: 'a> {
+#[unstable = "precise API still being fleshed out"]
+pub enum Entry<'a, K: 'a, V: 'a> {
/// An occupied Entry
Occupied(OccupiedEntry<'a, K, V>),
/// A vacant Entry
- Vacant(VacantEntry<'a, Q, K, V>),
+ Vacant(VacantEntry<'a, K, V>),
}
/// Possible states of a VacantEntry
}
}
-impl<'a, Q: ?Sized, K, V> Entry<'a, Q, K, V> {
- #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
+#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
+impl<'a, K, V> Entry<'a, K, V> {
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
- pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> {
+ pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
match self {
Occupied(entry) => Ok(entry.into_mut()),
Vacant(entry) => Err(entry),
}
}
+#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
impl<'a, K, V> OccupiedEntry<'a, K, V> {
- #[stable]
/// Gets a reference to the value in the entry
pub fn get(&self) -> &V {
self.elem.read().1
}
- #[stable]
/// Gets a mutable reference to the value in the entry
pub fn get_mut(&mut self) -> &mut V {
self.elem.read_mut().1
}
- #[stable]
/// Converts the OccupiedEntry into a mutable reference to the value in the entry
/// with a lifetime bound to the map itself
pub fn into_mut(self) -> &'a mut V {
self.elem.into_mut_refs().1
}
- #[stable]
/// Sets the value of the entry, and returns the entry's old value
pub fn insert(&mut self, mut value: V) -> V {
let old_value = self.get_mut();
value
}
- #[stable]
/// Takes the value out of the entry, and returns it
pub fn remove(self) -> V {
pop_internal(self.elem).1
}
}
-impl<'a, Q: ?Sized + 'a + ToOwned<K>, K: 'a, V: 'a> VacantEntry<'a, Q, K, V> {
- #[stable]
+#[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
+impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
/// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it
pub fn insert(self, value: V) -> &'a mut V {
match self.elem {
NeqElem(bucket, ib) => {
- robin_hood(bucket, ib, self.hash, self.key.to_owned(), value)
+ robin_hood(bucket, ib, self.hash, self.key, value)
}
NoElem(bucket) => {
- bucket.put(self.hash, self.key.to_owned(), value).into_mut_refs().1
+ bucket.put(self.hash, self.key, value).into_mut_refs().1
}
}
}
}
#[stable]
+#[old_impl_check]
impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, H> {
let lower = iter.size_hint().0;
}
#[stable]
+#[old_impl_check]
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Extend<(K, V)> for HashMap<K, V, H> {
fn extend<T: Iterator<Item=(K, V)>>(&mut self, mut iter: T) {
for (k, v) in iter {
use super::HashMap;
use super::Entry::{Occupied, Vacant};
use iter::{range_inclusive, range_step_inclusive, repeat};
- use borrow::ToOwned;
- use hash;
use cell::RefCell;
use rand::{weak_rng, Rng};
map.insert(1i, 2i);
map.insert(3i, 4i);
- let map_str = format!("{}", map);
+ let map_str = format!("{:?}", map);
- assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}");
- assert_eq!(format!("{}", empty), "{}");
+ assert!(map_str == "HashMap {1i: 2i, 3i: 4i}" ||
+ map_str == "HashMap {3i: 4i, 1i: 2i}");
+ assert_eq!(format!("{:?}", empty), "HashMap {}");
}
#[test]
let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
// Existing key (insert)
- match map.entry(&1) {
+ match map.entry(1) {
Vacant(_) => unreachable!(),
Occupied(mut view) => {
assert_eq!(view.get(), &10);
// Existing key (update)
- match map.entry(&2) {
+ match map.entry(2) {
Vacant(_) => unreachable!(),
Occupied(mut view) => {
let v = view.get_mut();
assert_eq!(map.len(), 6);
// Existing key (take)
- match map.entry(&3) {
+ match map.entry(3) {
Vacant(_) => unreachable!(),
Occupied(view) => {
assert_eq!(view.remove(), 30);
// Inexistent key (insert)
- match map.entry(&10) {
+ match map.entry(10) {
Occupied(_) => unreachable!(),
Vacant(view) => {
assert_eq!(*view.insert(1000), 1000);
for i in range(0u, 1000) {
let x = rng.gen_range(-10, 10);
- match m.entry(&x) {
+ match m.entry(x) {
Vacant(_) => {},
Occupied(e) => {
println!("{}: remove {}", i, x);
use borrow::BorrowFrom;
use clone::Clone;
use cmp::{Eq, PartialEq};
-use core::kinds::Sized;
+use core::marker::Sized;
use default::Default;
use fmt::Show;
use fmt;
use ops::{BitOr, BitAnd, BitXor, Sub};
use option::Option::{Some, None, self};
-// NOTE: for old macros; remove after the next snapshot
-#[cfg(stage0)] use result::Result::{Ok, Err};
-
use super::map::{self, HashMap, Keys, INITIAL_CAPACITY};
// Future Optimization (FIXME!)
///
/// // Use derived implementation to print the vikings.
/// for x in vikings.iter() {
-/// println!("{}", x);
+/// println!("{:?}", x);
/// }
/// ```
#[derive(Clone)]
}
}
+#[old_impl_check]
impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
/// Creates a new empty hash set which will use the given hasher to hash
/// keys.
}
#[stable]
+#[old_impl_check]
impl<T: Eq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> {
fn eq(&self, other: &HashSet<T, H>) -> bool {
if self.len() != other.len() { return false; }
}
#[stable]
+#[old_impl_check]
impl<T: Eq + Hash<S>, S, H: Hasher<S>> Eq for HashSet<T, H> {}
#[stable]
+#[old_impl_check]
impl<T: Eq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
+ try!(write!(f, "HashSet {{"));
for (i, x) in self.iter().enumerate() {
if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{}", *x));
+ try!(write!(f, "{:?}", *x));
}
write!(f, "}}")
}
#[stable]
+#[old_impl_check]
impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {
fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, H> {
let lower = iter.size_hint().0;
}
#[stable]
+#[old_impl_check]
impl<T: Eq + Hash<S>, S, H: Hasher<S>> Extend<T> for HashSet<T, H> {
fn extend<I: Iterator<Item=T>>(&mut self, mut iter: I) {
for k in iter {
}
#[stable]
+#[old_impl_check]
impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> Default for HashSet<T, H> {
#[stable]
fn default() -> HashSet<T, H> {
}
#[stable]
+#[old_impl_check]
impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
BitOr<&'b HashSet<T, H>> for &'a HashSet<T, H> {
type Output = HashSet<T, H>;
}
#[stable]
+#[old_impl_check]
impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
BitAnd<&'b HashSet<T, H>> for &'a HashSet<T, H> {
type Output = HashSet<T, H>;
}
#[stable]
+#[old_impl_check]
impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
BitXor<&'b HashSet<T, H>> for &'a HashSet<T, H> {
type Output = HashSet<T, H>;
}
#[stable]
+#[old_impl_check]
impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
Sub<&'b HashSet<T, H>> for &'a HashSet<T, H> {
type Output = HashSet<T, H>;
}
#[stable]
+#[old_impl_check]
impl<'a, T, S, H> Iterator for Intersection<'a, T, H>
where T: Eq + Hash<S>, H: Hasher<S>
{
}
#[stable]
+#[old_impl_check]
impl<'a, T, S, H> Iterator for Difference<'a, T, H>
where T: Eq + Hash<S>, H: Hasher<S>
{
}
#[stable]
+#[old_impl_check]
impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H>
where T: Eq + Hash<S>, H: Hasher<S>
{
}
#[stable]
+#[old_impl_check]
impl<'a, T, S, H> Iterator for Union<'a, T, H>
where T: Eq + Hash<S>, H: Hasher<S>
{
set.insert(1i);
set.insert(2);
- let set_str = format!("{}", set);
+ let set_str = format!("{:?}", set);
- assert!(set_str == "{1, 2}" || set_str == "{2, 1}");
- assert_eq!(format!("{}", empty), "{}");
+ assert!(set_str == "HashSet {1i, 2i}" || set_str == "HashSet {2i, 1i}");
+ assert_eq!(format!("{:?}", empty), "HashSet {}");
}
#[test]
use cmp;
use hash::{Hash, Hasher};
use iter::{Iterator, count};
-use kinds::{Copy, Sized, marker};
+use marker::{Copy, Sized, self};
use mem::{min_align_of, size_of};
use mem;
use num::{Int, UnsignedInt};
//! let message = "she sells sea shells by the sea shore";
//!
//! for c in message.chars() {
-//! match count.entry(&c) {
+//! match count.entry(c) {
//! Vacant(entry) => { entry.insert(1u); },
//! Occupied(mut entry) => *entry.get_mut() += 1,
//! }
//! for id in orders.into_iter() {
//! // If this is the first time we've seen this customer, initialize them
//! // with no blood alcohol. Otherwise, just retrieve them.
-//! let person = match blood_alcohol.entry(&id) {
+//! let person = match blood_alcohol.entry(id) {
//! Vacant(entry) => entry.insert(Person{id: id, blood_alcohol: 0.0}),
//! Occupied(entry) => entry.into_mut(),
//! };
//! }
//! ```
+#![stable]
+
use prelude::v1::*;
use str::Utf8Error;
use string::{FromUtf8Error, FromUtf16Error};
/// Base functionality for all errors in Rust.
+#[unstable = "the exact API of this trait may change"]
pub trait Error: Send {
/// A short description of the error; usually a static string.
fn description(&self) -> &str;
}
/// A trait for types that can be converted from a given error type `E`.
+#[stable]
pub trait FromError<E> {
/// Perform the conversion.
fn from_error(err: E) -> Self;
}
// Any type is convertable from itself
+#[stable]
impl<E> FromError<E> for E {
fn from_error(err: E) -> E {
err
}
}
+#[stable]
impl Error for Utf8Error {
fn description(&self) -> &str {
match *self {
fn detail(&self) -> Option<String> { Some(self.to_string()) }
}
+#[stable]
impl Error for FromUtf8Error {
fn description(&self) -> &str { "invalid utf-8" }
fn detail(&self) -> Option<String> { Some(self.to_string()) }
}
+#[stable]
impl Error for FromUtf16Error {
fn description(&self) -> &str { "invalid utf-16" }
}
let msg = match obj.downcast_ref::<&'static str>() {
Some(s) => *s,
None => match obj.downcast_ref::<String>() {
- Some(s) => s[],
+ Some(s) => s.index(&FullRange),
None => "Box<Any>",
}
};
//! format!("Hello"); // => "Hello"
//! format!("Hello, {}!", "world"); // => "Hello, world!"
//! format!("The number is {}", 1i); // => "The number is 1"
-//! format!("{}", (3i, 4i)); // => "(3, 4)"
+//! format!("{:?}", (3i, 4i)); // => "(3i, 4i)"
//! format!("{value}", value=4i); // => "4"
//! format!("{} {}", 1i, 2u); // => "1 2"
//! # }
//! # fn main() {
//! format!("{argument}", argument = "test"); // => "test"
//! format!("{name} {}", 1i, name = 2i); // => "2 1"
-//! format!("{a} {c} {b}", a="a", b=(), c=3i); // => "a 3 ()"
+//! format!("{a} {c} {b}", a="a", b='b', c=3i); // => "a 3 b"
//! # }
//! ```
//!
//! This allows multiple actual types to be formatted via `{:x}` (like `i8` as
//! well as `int`). The current mapping of types to traits is:
//!
-//! * *nothing* ⇒ `Show`
+//! * *nothing* ⇒ `String`
+//! * `?` ⇒ `Show`
//! * `o` ⇒ `Octal`
//! * `x` ⇒ `LowerHex`
//! * `X` ⇒ `UpperHex`
//! `std::fmt::Binary` trait can then be formatted with `{:b}`. Implementations
//! are provided for these traits for a number of primitive types by the
//! standard library as well. If no format is specified (as in `{}` or `{:6}`),
-//! then the format trait used is the `Show` trait. This is one of the more
-//! commonly implemented traits when formatting a custom type.
+//! then the format trait used is the `String` trait.
//!
//! When implementing a format trait for your own type, you will have to
//! implement a method of the signature:
//! use std::f64;
//! use std::num::Float;
//!
+//! #[deriving(Show)]
//! struct Vector2D {
//! x: int,
//! y: int,
//! }
//!
-//! impl fmt::Show for Vector2D {
+//! impl fmt::String for Vector2D {
//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
//! // The `f` value implements the `Writer` trait, which is what the
//! // write! macro is expecting. Note that this formatting ignores the
//! let myvector = Vector2D { x: 3, y: 4 };
//!
//! println!("{}", myvector); // => "(3, 4)"
+//! println!("{:?}", myvector); // => "Vector2D {x: 3i, y:4i}"
//! println!("{:10.3b}", myvector); // => " 5.000"
//! }
//! ```
//!
+//! #### fmt::String vs fmt::Show
+//!
+//! These two formatting traits have distinct purposes:
+//!
+//! - `fmt::String` implementations assert that the type can be faithfully
+//! represented as a UTF-8 string at all times. It is **not** expected that
+//! all types implement the `String` trait.
+//! - `fmt::Show` implementations should be implemented for **all** public types.
+//! Output will typically represent the internal state as faithfully as possible.
+//! The purpose of the `Show` trait is to facilitate debugging Rust code. In
+//! most cases, using `#[deriving(Show)]` is sufficient and recommended.
+//!
+//! Some examples of the output from both traits:
+//!
+//! ```
+//! assert_eq!(format!("{} {:?}", 3i32, 4i32), "3 4i32");
+//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");
+//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
+//! ```
+//!
//! ### Related macros
//!
//! There are a number of related macros in the `format!` family. The ones that
use string;
pub use core::fmt::{Formatter, Result, Writer, rt};
-pub use core::fmt::{Show, Octal, Binary};
+pub use core::fmt::{Show, String, Octal, Binary};
pub use core::fmt::{LowerHex, UpperHex, Pointer};
pub use core::fmt::{LowerExp, UpperExp};
pub use core::fmt::Error;
pub use core::hash::{Hash, Hasher, Writer, hash, sip};
-use core::kinds::Sized;
+use core::marker::Sized;
use default::Default;
use rand::Rng;
use rand;
use cmp;
use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
use iter::{IteratorExt, ExactSizeIterator};
-use ops::Drop;
+use ops::{Drop, Index};
use option::Option;
use option::Option::{Some, None};
use result::Result::Ok;
use slice;
use vec::Vec;
-// NOTE: for old macros; remove after the next snapshot
-#[cfg(stage0)] use result::Result::Err;
-
/// Wraps a Reader and buffers input from it
///
/// It can be excessively inefficient to work directly with a `Reader`. For
self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
self.pos = 0;
}
- Ok(self.buf[self.pos..self.cap])
+ Ok(self.buf.index(&(self.pos..self.cap)))
}
fn consume(&mut self, amt: uint) {
let nread = {
let available = try!(self.fill_buf());
let nread = cmp::min(available.len(), buf.len());
- slice::bytes::copy_memory(buf, available[..nread]);
+ slice::bytes::copy_memory(buf, available.index(&(0..nread)));
nread
};
self.pos += nread;
fn flush_buf(&mut self) -> IoResult<()> {
if self.pos != 0 {
- let ret = self.inner.as_mut().unwrap().write(self.buf[..self.pos]);
+ let ret = self.inner.as_mut().unwrap().write(self.buf.index(&(0..self.pos)));
self.pos = 0;
ret
} else {
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
match buf.iter().rposition(|&b| b == b'\n') {
Some(i) => {
- try!(self.inner.write(buf[..i + 1]));
+ try!(self.inner.write(buf.index(&(0..(i + 1)))));
try!(self.inner.flush());
- try!(self.inner.write(buf[i + 1..]));
+ try!(self.inner.write(buf.index(&((i + 1)..))));
Ok(())
}
None => self.inner.write(buf),
writer.write(&[0, 1]).unwrap();
let b: &[_] = &[];
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.write(&[2]).unwrap();
let b: &[_] = &[0, 1];
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.write(&[3]).unwrap();
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.flush().unwrap();
let a: &[_] = &[0, 1, 2, 3];
- assert_eq!(a, writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[]);
writer.write(&[4]).unwrap();
writer.write(&[5]).unwrap();
- assert_eq!(a, writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[]);
writer.write(&[6]).unwrap();
let a: &[_] = &[0, 1, 2, 3, 4, 5];
- assert_eq!(a,
- writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[]);
writer.write(&[7, 8]).unwrap();
let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
- assert_eq!(a,
- writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[]);
writer.write(&[9, 10, 11]).unwrap();
let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
- assert_eq!(a,
- writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[]);
writer.flush().unwrap();
- assert_eq!(a,
- writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[]);
}
#[test]
let mut w = BufferedWriter::with_capacity(3, Vec::new());
w.write(&[0, 1]).unwrap();
let a: &[_] = &[];
- assert_eq!(a, w.get_ref()[]);
+ assert_eq!(a, &w.get_ref()[]);
let w = w.into_inner();
let a: &[_] = &[0, 1];
- assert_eq!(a, w[]);
+ assert_eq!(a, w.index(&FullRange));
}
// This is just here to make sure that we don't infinite loop in the
let mut writer = LineBufferedWriter::new(Vec::new());
writer.write(&[0]).unwrap();
let b: &[_] = &[];
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.write(&[1]).unwrap();
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.flush().unwrap();
let b: &[_] = &[0, 1];
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.flush().unwrap();
let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
writer.write(&[3, b'\n']).unwrap();
let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
- assert_eq!(writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[], b);
}
#[test]
#[test]
fn read_char_buffered() {
let buf = [195u8, 159u8];
- let mut reader = BufferedReader::with_capacity(1, buf[]);
+ let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
assert_eq!(reader.read_char(), Ok('ß'));
}
#[test]
fn test_chars() {
let buf = [195u8, 159u8, b'a'];
- let mut reader = BufferedReader::with_capacity(1, buf[]);
+ let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
let mut it = reader.chars();
assert_eq!(it.next(), Some(Ok('ß')));
assert_eq!(it.next(), Some(Ok('a')));
use sync::mpsc::{Sender, Receiver};
use io;
use option::Option::{None, Some};
+use ops::Index;
use result::Result::{Ok, Err};
use slice::{bytes, SliceExt};
use super::{Buffer, Reader, Writer, IoResult};
Some(src) => {
let dst = buf.slice_from_mut(num_read);
let count = cmp::min(src.len(), dst.len());
- bytes::copy_memory(dst, src[..count]);
+ bytes::copy_memory(dst, src.index(&(0..count)));
count
},
None => 0,
tx.send(vec![3u8, 4u8]).unwrap();
tx.send(vec![5u8, 6u8]).unwrap();
tx.send(vec![7u8, 8u8]).unwrap();
- }).detach();
+ });
let mut reader = ChanReader::new(rx);
let mut buf = [0u8; 3];
tx.send(b"rld\nhow ".to_vec()).unwrap();
tx.send(b"are you?".to_vec()).unwrap();
tx.send(b"".to_vec()).unwrap();
- }).detach();
+ });
let mut reader = ChanReader::new(rx);
writer.write_be_u32(42).unwrap();
let wanted = vec![0u8, 0u8, 0u8, 42u8];
- let got = match Thread::spawn(move|| { rx.recv().unwrap() }).join() {
+ let got = match Thread::scoped(move|| { rx.recv().unwrap() }).join() {
Ok(got) => got,
Err(_) => panic!(),
};
})
}
}).update_err("couldn't open path as file", |e| {
- format!("{}; path={}; mode={}; access={}", e, path.display(),
+ format!("{}; path={:?}; mode={}; access={}", e, path.display(),
mode_string(mode), access_string(access))
})
}
pub fn fsync(&mut self) -> IoResult<()> {
self.fd.fsync()
.update_err("couldn't fsync file",
- |e| format!("{}; path={}", e, self.path.display()))
+ |e| format!("{}; path={:?}", e, self.path.display()))
}
/// This function is similar to `fsync`, except that it may not synchronize
pub fn datasync(&mut self) -> IoResult<()> {
self.fd.datasync()
.update_err("couldn't datasync file",
- |e| format!("{}; path={}", e, self.path.display()))
+ |e| format!("{}; path={:?}", e, self.path.display()))
}
/// Either truncates or extends the underlying file, updating the size of
pub fn truncate(&mut self, size: i64) -> IoResult<()> {
self.fd.truncate(size)
.update_err("couldn't truncate file", |e|
- format!("{}; path={}; size={}", e, self.path.display(), size))
+ format!("{}; path={:?}; size={:?}", e, self.path.display(), size))
}
/// Returns true if the stream has reached the end of the file.
pub fn stat(&self) -> IoResult<FileStat> {
self.fd.fstat()
.update_err("couldn't fstat file", |e|
- format!("{}; path={}", e, self.path.display()))
+ format!("{}; path={:?}", e, self.path.display()))
}
}
pub fn unlink(path: &Path) -> IoResult<()> {
fs_imp::unlink(path)
.update_err("couldn't unlink path", |e|
- format!("{}; path={}", e, path.display()))
+ format!("{}; path={:?}", e, path.display()))
}
/// Given a path, query the file system to get information about a file,
pub fn stat(path: &Path) -> IoResult<FileStat> {
fs_imp::stat(path)
.update_err("couldn't stat path", |e|
- format!("{}; path={}", e, path.display()))
+ format!("{}; path={:?}", e, path.display()))
}
/// Perform the same operation as the `stat` function, except that this
pub fn lstat(path: &Path) -> IoResult<FileStat> {
fs_imp::lstat(path)
.update_err("couldn't lstat path", |e|
- format!("{}; path={}", e, path.display()))
+ format!("{}; path={:?}", e, path.display()))
}
/// Rename a file or directory to a new name.
pub fn rename(from: &Path, to: &Path) -> IoResult<()> {
fs_imp::rename(from, to)
.update_err("couldn't rename path", |e|
- format!("{}; from={}; to={}", e, from.display(), to.display()))
+ format!("{}; from={:?}; to={:?}", e, from.display(), to.display()))
}
/// Copies the contents of one file to another. This function will also
pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
fn update_err<T>(result: IoResult<T>, from: &Path, to: &Path) -> IoResult<T> {
result.update_err("couldn't copy path", |e| {
- format!("{}; from={}; to={}", e, from.display(), to.display())
+ format!("{}; from={:?}; to={:?}", e, from.display(), to.display())
})
}
pub fn chmod(path: &Path, mode: io::FilePermission) -> IoResult<()> {
fs_imp::chmod(path, mode.bits() as uint)
.update_err("couldn't chmod path", |e|
- format!("{}; path={}; mode={}", e, path.display(), mode))
+ format!("{}; path={:?}; mode={:?}", e, path.display(), mode))
}
/// Change the user and group owners of a file at the specified path.
pub fn chown(path: &Path, uid: int, gid: int) -> IoResult<()> {
fs_imp::chown(path, uid, gid)
.update_err("couldn't chown path", |e|
- format!("{}; path={}; uid={}; gid={}", e, path.display(), uid, gid))
+ format!("{}; path={:?}; uid={}; gid={}", e, path.display(), uid, gid))
}
/// Creates a new hard link on the filesystem. The `dst` path will be a
pub fn link(src: &Path, dst: &Path) -> IoResult<()> {
fs_imp::link(src, dst)
.update_err("couldn't link path", |e|
- format!("{}; src={}; dest={}", e, src.display(), dst.display()))
+ format!("{}; src={:?}; dest={:?}", e, src.display(), dst.display()))
}
/// Creates a new symbolic link on the filesystem. The `dst` path will be a
pub fn symlink(src: &Path, dst: &Path) -> IoResult<()> {
fs_imp::symlink(src, dst)
.update_err("couldn't symlink path", |e|
- format!("{}; src={}; dest={}", e, src.display(), dst.display()))
+ format!("{}; src={:?}; dest={:?}", e, src.display(), dst.display()))
}
/// Reads a symlink, returning the file that the symlink points to.
pub fn readlink(path: &Path) -> IoResult<Path> {
fs_imp::readlink(path)
.update_err("couldn't resolve symlink for path", |e|
- format!("{}; path={}", e, path.display()))
+ format!("{}; path={:?}", e, path.display()))
}
/// Create a new, empty directory at the provided path
pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> {
fs_imp::mkdir(path, mode.bits() as uint)
.update_err("couldn't create directory", |e|
- format!("{}; path={}; mode={}", e, path.display(), mode))
+ format!("{}; path={:?}; mode={:?}", e, path.display(), mode))
}
/// Remove an existing, empty directory
pub fn rmdir(path: &Path) -> IoResult<()> {
fs_imp::rmdir(path)
.update_err("couldn't remove directory", |e|
- format!("{}; path={}", e, path.display()))
+ format!("{}; path={:?}", e, path.display()))
}
/// Retrieve a vector containing all entries within a provided directory
pub fn readdir(path: &Path) -> IoResult<Vec<Path>> {
fs_imp::readdir(path)
.update_err("couldn't read directory",
- |e| format!("{}; path={}", e, path.display()))
+ |e| format!("{}; path={:?}", e, path.display()))
}
/// Returns an iterator that will recursively walk the directory structure
pub fn walk_dir(path: &Path) -> IoResult<Directories> {
Ok(Directories {
stack: try!(readdir(path).update_err("couldn't walk directory",
- |e| format!("{}; path={}", e, path.display())))
+ |e| format!("{}; path={:?}", e, path.display())))
})
}
let result = mkdir(&curpath, mode)
.update_err("couldn't recursively mkdir",
- |e| format!("{}; path={}", e, path.display()));
+ |e| format!("{}; path={:?}", e, path.display()));
match result {
Err(mkdir_err) => {
rm_stack.push(path.clone());
fn rmdir_failed(err: &IoError, path: &Path) -> String {
- format!("rmdir_recursive failed; path={}; cause={}",
+ format!("rmdir_recursive failed; path={:?}; cause={}",
path.display(), err)
}
pub fn change_file_times(path: &Path, atime: u64, mtime: u64) -> IoResult<()> {
fs_imp::utime(path, atime, mtime)
.update_err("couldn't change_file_times", |e|
- format!("{}; path={}", e, path.display()))
+ format!("{}; path={:?}", e, path.display()))
}
impl Reader for File {
fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
fn update_err<T>(result: IoResult<T>, file: &File) -> IoResult<T> {
result.update_err("couldn't read file",
- |e| format!("{}; path={}",
+ |e| format!("{}; path={:?}",
e, file.path.display()))
}
fn write(&mut self, buf: &[u8]) -> IoResult<()> {
self.fd.write(buf)
.update_err("couldn't write to file",
- |e| format!("{}; path={}", e, self.path.display()))
+ |e| format!("{}; path={:?}", e, self.path.display()))
}
}
fn tell(&self) -> IoResult<u64> {
self.fd.tell()
.update_err("couldn't retrieve file cursor (`tell`)",
- |e| format!("{}; path={}", e, self.path.display()))
+ |e| format!("{}; path={:?}", e, self.path.display()))
}
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
Err(e) => Err(e),
};
err.update_err("couldn't seek in file",
- |e| format!("{}; path={}", e, self.path.display()))
+ |e| format!("{}; path={:?}", e, self.path.display()))
}
}
macro_rules! check { ($e:expr) => (
match $e {
Ok(t) => t,
- Err(e) => panic!("{} failed with: {}", stringify!($e), e),
+ Err(e) => panic!("{} failed with: {:?}", stringify!($e), e),
}
) }
macro_rules! error { ($e:expr, $s:expr) => (
match $e {
- Ok(_) => panic!("Unexpected success. Should've been: {}", $s),
+ Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
Err(ref err) => assert!(err.to_string().contains($s.as_slice()),
format!("`{}` did not contain `{}`", err, $s))
}
let mut read_buf = [0; 1028];
let read_str = match check!(read_stream.read(&mut read_buf)) {
-1|0 => panic!("shouldn't happen"),
- n => str::from_utf8(read_buf[..n]).unwrap().to_string()
+ n => str::from_utf8(read_buf.index(&(0..n))).unwrap().to_string()
};
assert_eq!(read_str.as_slice(), message);
}
if cfg!(unix) {
error!(result, "no such file or directory");
}
- error!(result, format!("path={}; mode=open; access=read", filename.display()));
+ error!(result, format!("path={:?}; mode=open; access=read", filename.display()));
}
#[test]
if cfg!(unix) {
error!(result, "no such file or directory");
}
- error!(result, format!("path={}", filename.display()));
+ error!(result, format!("path={:?}", filename.display()));
}
#[test]
error!(result, "couldn't recursively mkdir");
error!(result, "couldn't create directory");
error!(result, "mode=0700");
- error!(result, format!("path={}", file.display()));
+ error!(result, format!("path={:?}", file.display()));
}
#[test]
error!(copy(&from, &to),
format!("couldn't copy path (the source path is not an \
- existing file; from={}; to={})",
+ existing file; from={:?}; to={:?})",
from.display(), to.display()));
match copy(&from, &to) {
//! Readers and Writers for in-memory buffers
use cmp::min;
+use ops::Index;
use option::Option::None;
use result::Result::{Err, Ok};
use io;
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
- let input = self.buf[self.pos.. self.pos + write_len];
+ let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
let output = buf.slice_to_mut(write_len);
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
#[inline]
fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
if self.pos < self.buf.len() {
- Ok(self.buf[self.pos..])
+ Ok(self.buf.index(&(self.pos..)))
} else {
Err(io::standard_error(io::EndOfFile))
}
let write_len = min(buf.len(), self.len());
{
- let input = self[..write_len];
+ let input = self.index(&(0..write_len));
let output = buf.slice_to_mut(write_len);
slice::bytes::copy_memory(output, input);
}
#[inline]
fn consume(&mut self, amt: uint) {
- *self = self[amt..];
+ *self = self.index(&(amt..));
}
}
Ok(())
} else {
- slice::bytes::copy_memory(dst, src[..dst_len]);
+ slice::bytes::copy_memory(dst, src.index(&(0..dst_len)));
self.pos += dst_len;
let write_len = min(buf.len(), self.buf.len() - self.pos);
{
- let input = self.buf[self.pos.. self.pos + write_len];
+ let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
let output = buf.slice_to_mut(write_len);
assert_eq!(input.len(), output.len());
slice::bytes::copy_memory(output, input);
#[inline]
fn fill_buf(&mut self) -> IoResult<&[u8]> {
if self.pos < self.buf.len() {
- Ok(self.buf[self.pos..])
+ Ok(self.buf.index(&(self.pos..)))
} else {
Err(io::standard_error(io::EndOfFile))
}
#[cfg(test)]
mod test {
extern crate "test" as test_crate;
- use prelude::v1::*;
-
- use io::{SeekSet, SeekCur, SeekEnd};
+ use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
+ use prelude::v1::{Ok, Err, range, Vec, Buffer, AsSlice, SliceExt};
+ use prelude::v1::{IteratorExt, Index};
use io;
use iter::repeat;
use self::test_crate::Bencher;
assert_eq!(buf, b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
- assert_eq!(buf[0..3], b);
+ assert_eq!(buf.index(&(0..3)), b);
assert!(reader.read(&mut buf).is_err());
let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
assert_eq!(buf.as_slice(), b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
- assert_eq!(buf[0..3], b);
+ assert_eq!(buf.index(&(0..3)), b);
assert!(reader.read(&mut buf).is_err());
let mut reader = &mut in_buf.as_slice();
assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
assert_eq!(buf, b);
assert_eq!(reader.read(&mut buf), Ok(3));
let b: &[_] = &[5, 6, 7];
- assert_eq!(buf[0..3], b);
+ assert_eq!(buf.index(&(0..3)), b);
assert!(reader.read(&mut buf).is_err());
let mut reader = BufReader::new(in_buf.as_slice());
assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
//! for stream in acceptor.incoming() {
//! match stream {
//! Err(e) => { /* connection failed */ }
-//! Ok(stream) => Thread::spawn(move|| {
-//! // connection succeeded
-//! handle_client(stream)
-//! }).detach()
+//! Ok(stream) => {
+//! Thread::spawn(move|| {
+//! // connection succeeded
+//! handle_client(stream)
+//! });
+//! }
//! }
//! }
//!
use fmt;
use int;
use iter::{Iterator, IteratorExt};
-use kinds::Sized;
+use marker::Sized;
use mem::transmute;
-use ops::FnOnce;
+use ops::{FnOnce, Index};
use option::Option;
use option::Option::{Some, None};
use os;
pub mod timer;
pub mod util;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod test;
/// The default buffer size for various I/O operations
/// # FIXME
///
/// Is something like this sufficient? It's kind of archaic
-#[derive(PartialEq, Eq, Clone)]
+#[derive(PartialEq, Eq, Clone, Show)]
pub struct IoError {
/// An enumeration which can be matched against for determining the flavor
/// of error.
}
}
-impl fmt::Show for IoError {
+impl fmt::String for IoError {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
IoError { kind: OtherIoError, desc: "unknown error", detail: Some(ref detail) } =>
fn write_char(&mut self, c: char) -> IoResult<()> {
let mut buf = [0u8; 4];
let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
- self.write(buf[..n])
+ self.write(buf.index(&(0..n)))
}
/// Write the result of passing n through `int::to_str_bytes`.
};
match available.iter().position(|&b| b == byte) {
Some(i) => {
- res.push_all(available[..i + 1]);
+ res.push_all(available.index(&(0..(i + 1))));
used = i + 1;
break
}
}
}
}
- match str::from_utf8(buf[..width]).ok() {
+ match str::from_utf8(buf.index(&(0..width))).ok() {
Some(s) => Ok(s.char_at(0)),
None => Err(standard_error(InvalidInput))
}
inc: &'a mut A,
}
+#[old_impl_check]
impl<'a, T, A: ?Sized + Acceptor<T>> Iterator for IncomingConnections<'a, A> {
type Item = IoResult<T>;
/// A mode specifies how a file should be opened or created. These modes are
/// passed to `File::open_mode` and are used to control where the file is
/// positioned when it is initially opened.
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq, Show)]
pub enum FileMode {
/// Opens a file positioned at the beginning.
Open,
/// Access permissions with which the file should be opened. `File`s
/// opened with `Read` will return an error if written to.
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq, Show)]
pub enum FileAccess {
/// Read-only access, requests to write will result in an error
Read,
pub gen: u64,
}
+
+// NOTE(stage0): change this one last #[doc=..] to /// after the next snapshot
bitflags! {
- #[doc = "A set of permissions for a file or directory is represented"]
- #[doc = "by a set of flags which are or'd together."]
+ #[doc = "A set of permissions for a file or directory is represented by a set of"]
+ /// flags which are or'd together.
flags FilePermission: u32 {
const USER_READ = 0o400,
const USER_WRITE = 0o200,
const GROUP_RWX = GROUP_READ.bits | GROUP_WRITE.bits | GROUP_EXECUTE.bits,
const OTHER_RWX = OTHER_READ.bits | OTHER_WRITE.bits | OTHER_EXECUTE.bits,
- #[doc = "Permissions for user owned files, equivalent to 0644 on"]
- #[doc = "unix-like systems."]
+ /// Permissions for user owned files, equivalent to 0644 on unix-like
+ /// systems.
const USER_FILE = USER_READ.bits | USER_WRITE.bits | GROUP_READ.bits | OTHER_READ.bits,
- #[doc = "Permissions for user owned directories, equivalent to 0755 on"]
- #[doc = "unix-like systems."]
+ /// Permissions for user owned directories, equivalent to 0755 on
+ /// unix-like systems.
const USER_DIR = USER_RWX.bits | GROUP_READ.bits | GROUP_EXECUTE.bits |
OTHER_READ.bits | OTHER_EXECUTE.bits,
- #[doc = "Permissions for user owned executables, equivalent to 0755"]
- #[doc = "on unix-like systems."]
+ /// Permissions for user owned executables, equivalent to 0755
+ /// on unix-like systems.
const USER_EXEC = USER_DIR.bits,
- #[doc = "All possible permissions enabled."]
+ /// All possible permissions enabled.
const ALL_PERMISSIONS = USER_RWX.bits | GROUP_RWX.bits | OTHER_RWX.bits,
}
}
}
impl fmt::Show for FilePermission {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for FilePermission {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:04o}", self.bits)
}
use vec::Vec;
/// Hints to the types of sockets that are desired when looking up hosts
-#[derive(Copy)]
+#[derive(Copy, Show)]
pub enum SocketType {
Stream, Datagram, Raw
}
/// to manipulate how a query is performed.
///
/// The meaning of each of these flags can be found with `man -s 3 getaddrinfo`
-#[derive(Copy)]
+#[derive(Copy, Show)]
pub enum Flag {
AddrConfig,
All,
/// A transport protocol associated with either a hint or a return value of
/// `lookup`
-#[derive(Copy)]
+#[derive(Copy, Show)]
pub enum Protocol {
TCP, UDP
}
///
/// For details on these fields, see their corresponding definitions via
/// `man -s 3 getaddrinfo`
-#[derive(Copy)]
+#[derive(Copy, Show)]
pub struct Hint {
pub family: uint,
pub socktype: Option<SocketType>,
pub flags: uint,
}
-#[derive(Copy)]
+#[derive(Copy, Show)]
pub struct Info {
pub address: SocketAddr,
pub family: uint,
use io::{self, IoResult, IoError};
use io::net;
use iter::{Iterator, IteratorExt};
-use ops::{FnOnce, FnMut};
+use ops::{FnOnce, FnMut, Index};
use option::Option;
use option::Option::{None, Some};
use result::Result::{Ok, Err};
pub type Port = u16;
-#[derive(Copy, PartialEq, Eq, Clone, Hash)]
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Show)]
pub enum IpAddr {
Ipv4Addr(u8, u8, u8, u8),
Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16)
}
-impl fmt::Show for IpAddr {
+impl fmt::String for IpAddr {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
match *self {
Ipv4Addr(a, b, c, d) =>
}
}
-#[derive(Copy, PartialEq, Eq, Clone, Hash)]
+#[derive(Copy, PartialEq, Eq, Clone, Hash, Show)]
pub struct SocketAddr {
pub ip: IpAddr,
pub port: Port,
}
-impl fmt::Show for SocketAddr {
+impl fmt::String for SocketAddr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self.ip {
Ipv4Addr(..) => write!(f, "{}:{}", self.ip, self.port),
let mut tail = [0u16; 8];
let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
- Some(ipv6_addr_from_head_tail(head[..head_size], tail[..tail_size]))
+ Some(ipv6_addr_from_head_tail(head.index(&(0..head_size)), tail.index(&(0..tail_size))))
}
fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv();
- }).detach();
+ });
let mut b = [0];
let mut s = UnixStream::connect(&addr).unwrap();
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv();
- }).detach();
+ });
let mut s = UnixStream::connect(&addr).unwrap();
let s2 = s.clone();
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_timeout(Some(20));
}
}
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_read_timeout(Some(20));
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_write_timeout(Some(20));
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
let s2 = s.clone();
/// timer::sleep(Duration::seconds(1));
/// let mut stream = stream2;
/// stream.close_read();
- /// }).detach();
+ /// });
///
/// // wait for some data, will get canceled after one second
/// let mut buf = [0];
/// for stream in acceptor.incoming() {
/// match stream {
/// Err(e) => { /* connection failed */ }
-/// Ok(stream) => Thread::spawn(move|| {
-/// // connection succeeded
-/// handle_client(stream)
-/// }).detach()
+/// Ok(stream) => {
+/// Thread::spawn(move|| {
+/// // connection succeeded
+/// handle_client(stream)
+/// });
+/// }
/// }
/// }
///
/// Err(e) => panic!("unexpected error: {}", e),
/// }
/// }
- /// }).detach();
+ /// });
///
/// # fn wait_for_sigint() {}
/// // Now that our accept loop is running, wait for the program to be
Ok(..) => panic!(),
Err(ref e) => {
assert!(e.kind == NotConnected || e.kind == EndOfFile,
- "unknown kind: {}", e.kind);
+ "unknown kind: {:?}", e.kind);
}
}
}
Ok(..) => panic!(),
Err(ref e) => {
assert!(e.kind == NotConnected || e.kind == EndOfFile,
- "unknown kind: {}", e.kind);
+ "unknown kind: {:?}", e.kind);
}
}
}
Ok(..) => panic!(),
Err(e) => {
assert!(e.kind == ConnectionRefused || e.kind == OtherIoError,
- "unknown error: {} {}", e, e.kind);
+ "unknown error: {} {:?}", e, e.kind);
}
}
}
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv().unwrap();
- }).detach();
+ });
let mut b = [0];
let mut s = TcpStream::connect(addr).unwrap();
let mut a = a;
let _s = a.accept().unwrap();
let _ = rx.recv().unwrap();
- }).detach();
+ });
let mut s = TcpStream::connect(addr).unwrap();
let s2 = s.clone();
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_timeout(Some(20));
}
}
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_read_timeout(Some(20));
rx.recv().unwrap();
assert!(s.write(&[0]).is_ok());
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
s.set_write_timeout(Some(20));
rx.recv().unwrap();
assert_eq!(s.write(&[0]), Ok(()));
let _ = rx.recv();
- }).detach();
+ });
let mut s = a.accept().unwrap();
let s2 = s.clone();
}
}
+#[cfg(stage0)]
impl fmt::Show for Command {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for Command {
/// Format the program and arguments of a Command for display. Any
/// non-utf8 data is lossily converted using the utf8 replacement
/// character.
}
impl fmt::Show for ProcessExit {
+ /// Format a ProcessExit enum, to nicely present the information.
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+
+impl fmt::String for ProcessExit {
/// Format a ProcessExit enum, to nicely present the information.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Thread::spawn(move |:| {
let mut stream = stream;
tx.send(stream.read_to_end()).unwrap();
- }).detach();
+ });
}
None => tx.send(Ok(Vec::new())).unwrap()
}
#[cfg(test)]
mod tests {
- use prelude::v1::*;
-
+ use io::{Truncate, Write, TimedOut, timer, process, FileNotFound};
+ use prelude::v1::{Ok, Err, range, drop, Some, None, Vec};
+ use prelude::v1::{Path, String, Reader, Writer, Clone};
+ use prelude::v1::{SliceExt, Str, StrExt, AsSlice, ToString, GenericPath};
use io::fs::PathExtensions;
- use io::process;
use io::timer::*;
- use io::{Truncate, Write, TimedOut, timer, FileNotFound};
use rt::running_on_valgrind;
use str;
use super::{CreatePipe};
use fmt;
use io::{Reader, Writer, IoResult, IoError, OtherIoError, Buffer,
standard_error, EndOfFile, LineBufferedWriter, BufferedReader};
-use kinds::{Sync, Send};
+use marker::{Sync, Send};
use libc;
use mem;
use option::Option;
});
match result {
Ok(()) => {}
- Err(e) => panic!("failed printing to stdout: {}", e),
+ Err(e) => panic!("failed printing to stdout: {:?}", e),
}
}
Thread::spawn(move|| {
let _ = timer_rx.recv();
- }).detach();
+ });
// when we drop the TimerWatcher we're going to destroy the channel,
// which must wake up the task on the other end
Thread::spawn(move|| {
let _ = timer_rx.recv();
- }).detach();
+ });
timer.oneshot(Duration::milliseconds(1));
}
Thread::spawn(move|| {
let _ = timer_rx.recv();
- }).detach();
+ });
timer.sleep(Duration::milliseconds(1));
}
impl<R: Buffer> Buffer for LimitReader<R> {
fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
let amt = try!(self.inner.fill_buf());
- let buf = amt[..cmp::min(amt.len(), self.limit)];
+ let buf = amt.index(&(0..cmp::min(amt.len(), self.limit)));
if buf.len() == 0 {
Err(io::standard_error(io::EndOfFile))
} else {
impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
self.reader.read(buf).and_then(|len| {
- self.writer.write(buf[mut ..len]).map(|()| len)
+ self.writer.write(buf.index_mut(&(0..len))).map(|()| len)
})
}
}
Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
Err(e) => return Err(e),
};
- try!(w.write(buf[..len]));
+ try!(w.write(buf.index(&(0..len))));
}
}
//!
//! The [`ptr`](ptr/index.html) and [`mem`](mem/index.html)
//! modules deal with unsafe pointers and memory manipulation.
-//! [`kinds`](kinds/index.html) defines the special built-in traits,
+//! [`markers`](markers/index.html) defines the special built-in traits,
//! and [`raw`](raw/index.html) the runtime representation of Rust types.
//! These are some of the lowest-level building blocks in Rust.
//!
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
-#![feature(macro_rules, globs, linkage, thread_local, asm)]
-#![feature(default_type_params, phase, lang_items, unsafe_destructor)]
+#![feature(linkage, thread_local, asm)]
+#![feature(lang_items, unsafe_destructor)]
#![feature(slicing_syntax, unboxed_closures)]
-#![feature(old_orphan_check)]
-#![feature(associated_types)]
+#![feature(old_impl_check)]
+#![cfg_attr(stage0, allow(unused_attributes))]
// Don't link to std. We are std.
#![no_std]
#![deny(missing_docs)]
-#![reexport_test_harness_main = "test_main"]
-
-#[cfg(all(test, stage0))]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(all(test, not(stage0)))]
+#[cfg(test)]
#[macro_use]
extern crate log;
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate core;
-
-#[cfg(not(stage0))]
#[macro_use]
#[macro_reexport(assert, assert_eq, debug_assert, debug_assert_eq,
- unreachable, unimplemented, write, writeln)]
+ unreachable, unimplemented, write, writeln)]
extern crate core;
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate "collections" as core_collections;
-
-#[cfg(not(stage0))]
#[macro_use]
#[macro_reexport(vec)]
extern crate "collections" as core_collections;
// Make std testable by not duplicating lang items. See #2912
#[cfg(test)] extern crate "std" as realstd;
-#[cfg(test)] pub use realstd::kinds;
+#[cfg(test)] pub use realstd::marker;
#[cfg(test)] pub use realstd::ops;
#[cfg(test)] pub use realstd::cmp;
#[cfg(test)] pub use realstd::boxed;
pub use core::finally;
pub use core::intrinsics;
pub use core::iter;
-#[cfg(not(test))] pub use core::kinds;
+#[cfg(stage0)] #[cfg(not(test))] pub use core::marker as kinds;
+#[cfg(not(test))] pub use core::marker;
pub use core::mem;
#[cfg(not(test))] pub use core::ops;
pub use core::ptr;
/* Exported macros */
-#[cfg(stage0)]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
-pub mod macros_stage0;
-
-#[cfg(not(stage0))]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod macros;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod bitflags;
mod rtdeps;
/* Primitive types */
#[path = "num/float_macros.rs"]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod float_macros;
#[path = "num/int_macros.rs"]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod int_macros;
#[path = "num/uint_macros.rs"]
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod uint_macros;
#[path = "num/int.rs"] pub mod int;
/* Runtime and platform support */
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod thread_local;
pub mod dynamic_lib;
pub use vec; // used for vec![]
pub use cell; // used for tls!
pub use thread_local; // used for thread_local!
- pub use kinds; // used for tls!
+ #[cfg(stage0)]
+ pub use marker as kinds;
+ pub use marker; // used for tls!
pub use ops; // used for bitflags!
// The test runner calls ::std::os::args() but really wants realstd
if !((*left_val == *right_val) &&
(*right_val == *left_val)) {
panic!("assertion failed: `(left == right) && (right == left)` \
- (left: `{}`, right: `{}`)", *left_val, *right_val)
+ (left: `{:?}`, right: `{:?}`)", *left_val, *right_val)
}
}
}
/// # fn long_running_task() {}
/// # fn calculate_the_answer() -> int { 42i }
///
-/// Thread::spawn(move|| { long_running_task(); tx1.send(()) }).detach();
-/// Thread::spawn(move|| { tx2.send(calculate_the_answer()) }).detach();
+/// Thread::spawn(move|| { long_running_task(); tx1.send(()).unwrap(); });
+/// Thread::spawn(move|| { tx2.send(calculate_the_answer()).unwrap(); });
///
/// select! (
/// _ = rx1.recv() => println!("the long running task finished first"),
///
/// ```
#[macro_export]
- macro_rules! format_args { ($fmt:expr $($args:tt)*) => ({
+ macro_rules! format_args { ($fmt:expr, $($args:tt)*) => ({
/* compiler built-in */
}) }
///
/// ```rust
/// let key: Option<&'static str> = option_env!("SECRET_KEY");
- /// println!("the secret key might be: {}", key);
+ /// println!("the secret key might be: {:?}", key);
/// ```
#[macro_export]
macro_rules! option_env { ($name:expr) => ({ /* compiler built-in */ }) }
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Standard library macros
-//!
-//! This modules contains a set of macros which are exported from the standard
-//! library. Each macro is available for use when linking against the standard
-//! library.
-
-#![experimental]
-
-/// The entry point for panic of Rust tasks.
-///
-/// This macro is used to inject panic into a Rust task, causing the task to
-/// unwind and panic entirely. Each task's panic can be reaped as the
-/// `Box<Any>` type, and the single-argument form of the `panic!` macro will be
-/// the value which is transmitted.
-///
-/// The multi-argument form of this macro panics with a string and has the
-/// `format!` syntax for building a string.
-///
-/// # Example
-///
-/// ```should_fail
-/// # #![allow(unreachable_code)]
-/// panic!();
-/// panic!("this is a terrible mistake!");
-/// panic!(4i); // panic with the value of 4 to be collected elsewhere
-/// panic!("this is a {} {message}", "fancy", message = "message");
-/// ```
-#[macro_export]
-macro_rules! panic {
- () => ({
- panic!("explicit panic")
- });
- ($msg:expr) => ({
- // static requires less code at runtime, more constant data
- static _FILE_LINE: (&'static str, uint) = (file!(), line!());
- ::std::rt::begin_unwind($msg, &_FILE_LINE)
- });
- ($fmt:expr, $($arg:tt)*) => ({
- // The leading _'s are to avoid dead code warnings if this is
- // used inside a dead function. Just `#[allow(dead_code)]` is
- // insufficient, since the user may have
- // `#[forbid(dead_code)]` and which cannot be overridden.
- static _FILE_LINE: (&'static str, uint) = (file!(), line!());
- ::std::rt::begin_unwind_fmt(format_args!($fmt, $($arg)*), &_FILE_LINE)
-
- });
-}
-
-/// Ensure that a boolean expression is `true` at runtime.
-///
-/// This will invoke the `panic!` macro if the provided expression cannot be
-/// evaluated to `true` at runtime.
-///
-/// # Example
-///
-/// ```
-/// // the panic message for these assertions is the stringified value of the
-/// // expression given.
-/// assert!(true);
-/// # fn some_computation() -> bool { true }
-/// assert!(some_computation());
-///
-/// // assert with a custom message
-/// # let x = true;
-/// assert!(x, "x wasn't true!");
-/// # let a = 3i; let b = 27i;
-/// assert!(a + b == 30, "a = {}, b = {}", a, b);
-/// ```
-#[macro_export]
-macro_rules! assert {
- ($cond:expr) => (
- if !$cond {
- panic!(concat!("assertion failed: ", stringify!($cond)))
- }
- );
- ($cond:expr, $($arg:expr),+) => (
- if !$cond {
- panic!($($arg),+)
- }
- );
-}
-
-/// Asserts that two expressions are equal to each other, testing equality in
-/// both directions.
-///
-/// On panic, this macro will print the values of the expressions.
-///
-/// # Example
-///
-/// ```
-/// let a = 3i;
-/// let b = 1i + 2i;
-/// assert_eq!(a, b);
-/// ```
-#[macro_export]
-macro_rules! assert_eq {
- ($left:expr , $right:expr) => ({
- match (&($left), &($right)) {
- (left_val, right_val) => {
- // check both directions of equality....
- if !((*left_val == *right_val) &&
- (*right_val == *left_val)) {
- panic!("assertion failed: `(left == right) && (right == left)` \
- (left: `{}`, right: `{}`)", *left_val, *right_val)
- }
- }
- }
- })
-}
-
-/// Ensure that a boolean expression is `true` at runtime.
-///
-/// This will invoke the `panic!` macro if the provided expression cannot be
-/// evaluated to `true` at runtime.
-///
-/// Unlike `assert!`, `debug_assert!` statements can be disabled by passing
-/// `--cfg ndebug` to the compiler. This makes `debug_assert!` useful for
-/// checks that are too expensive to be present in a release build but may be
-/// helpful during development.
-///
-/// # Example
-///
-/// ```
-/// // the panic message for these assertions is the stringified value of the
-/// // expression given.
-/// debug_assert!(true);
-/// # fn some_expensive_computation() -> bool { true }
-/// debug_assert!(some_expensive_computation());
-///
-/// // assert with a custom message
-/// # let x = true;
-/// debug_assert!(x, "x wasn't true!");
-/// # let a = 3i; let b = 27i;
-/// debug_assert!(a + b == 30, "a = {}, b = {}", a, b);
-/// ```
-#[macro_export]
-macro_rules! debug_assert {
- ($($arg:tt)*) => (if cfg!(not(ndebug)) { assert!($($arg)*); })
-}
-
-/// Asserts that two expressions are equal to each other, testing equality in
-/// both directions.
-///
-/// On panic, this macro will print the values of the expressions.
-///
-/// Unlike `assert_eq!`, `debug_assert_eq!` statements can be disabled by
-/// passing `--cfg ndebug` to the compiler. This makes `debug_assert_eq!`
-/// useful for checks that are too expensive to be present in a release build
-/// but may be helpful during development.
-///
-/// # Example
-///
-/// ```
-/// let a = 3i;
-/// let b = 1i + 2i;
-/// debug_assert_eq!(a, b);
-/// ```
-#[macro_export]
-macro_rules! debug_assert_eq {
- ($($arg:tt)*) => (if cfg!(not(ndebug)) { assert_eq!($($arg)*); })
-}
-
-/// A utility macro for indicating unreachable code.
-///
-/// This is useful any time that the compiler can't determine that some code is unreachable. For
-/// example:
-///
-/// * Match arms with guard conditions.
-/// * Loops that dynamically terminate.
-/// * Iterators that dynamically terminate.
-///
-/// # Panics
-///
-/// This will always panic.
-///
-/// # Examples
-///
-/// Match arms:
-///
-/// ```rust
-/// fn foo(x: Option<int>) {
-/// match x {
-/// Some(n) if n >= 0 => println!("Some(Non-negative)"),
-/// Some(n) if n < 0 => println!("Some(Negative)"),
-/// Some(_) => unreachable!(), // compile error if commented out
-/// None => println!("None")
-/// }
-/// }
-/// ```
-///
-/// Iterators:
-///
-/// ```rust
-/// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3
-/// for i in std::iter::count(0_u32, 1) {
-/// if 3*i < i { panic!("u32 overflow"); }
-/// if x < 3*i { return i-1; }
-/// }
-/// unreachable!();
-/// }
-/// ```
-#[macro_export]
-macro_rules! unreachable {
- () => ({
- panic!("internal error: entered unreachable code")
- });
- ($msg:expr) => ({
- unreachable!("{}", $msg)
- });
- ($fmt:expr, $($arg:tt)*) => ({
- panic!(concat!("internal error: entered unreachable code: ", $fmt), $($arg)*)
- });
-}
-
-/// A standardised placeholder for marking unfinished code. It panics with the
-/// message `"not yet implemented"` when executed.
-#[macro_export]
-macro_rules! unimplemented {
- () => (panic!("not yet implemented"))
-}
-
-/// Use the syntax described in `std::fmt` to create a value of type `String`.
-/// See `std::fmt` for more information.
-///
-/// # Example
-///
-/// ```
-/// format!("test");
-/// format!("hello {}", "world!");
-/// format!("x = {}, y = {y}", 10i, y = 30i);
-/// ```
-#[macro_export]
-#[stable]
-macro_rules! format {
- ($($arg:tt)*) => (::std::fmt::format(format_args!($($arg)*)))
-}
-
-/// Use the `format!` syntax to write data into a buffer of type `&mut Writer`.
-/// See `std::fmt` for more information.
-///
-/// # Example
-///
-/// ```
-/// # #![allow(unused_must_use)]
-///
-/// let mut w = Vec::new();
-/// write!(&mut w, "test");
-/// write!(&mut w, "formatted {}", "arguments");
-/// ```
-#[macro_export]
-#[stable]
-macro_rules! write {
- ($dst:expr, $($arg:tt)*) => ((&mut *$dst).write_fmt(format_args!($($arg)*)))
-}
-
-/// Equivalent to the `write!` macro, except that a newline is appended after
-/// the message is written.
-#[macro_export]
-#[stable]
-macro_rules! writeln {
- ($dst:expr, $fmt:expr $($arg:tt)*) => (
- write!($dst, concat!($fmt, "\n") $($arg)*)
- )
-}
-
-/// Equivalent to the `println!` macro except that a newline is not printed at
-/// the end of the message.
-#[macro_export]
-#[stable]
-macro_rules! print {
- ($($arg:tt)*) => (::std::io::stdio::print_args(format_args!($($arg)*)))
-}
-
-/// Macro for printing to a task's stdout handle.
-///
-/// Each task can override its stdout handle via `std::io::stdio::set_stdout`.
-/// The syntax of this macro is the same as that used for `format!`. For more
-/// information, see `std::fmt` and `std::io::stdio`.
-///
-/// # Example
-///
-/// ```
-/// println!("hello there!");
-/// println!("format {} arguments", "some");
-/// ```
-#[macro_export]
-#[stable]
-macro_rules! println {
- ($($arg:tt)*) => (::std::io::stdio::println_args(format_args!($($arg)*)))
-}
-
-/// Helper macro for unwrapping `Result` values while returning early with an
-/// error if the value of the expression is `Err`. For more information, see
-/// `std::io`.
-#[macro_export]
-macro_rules! try {
- ($expr:expr) => ({
- match $expr {
- Ok(val) => val,
- Err(err) => return Err(::std::error::FromError::from_error(err))
- }
- })
-}
-
-/// Create a `std::vec::Vec` containing the arguments.
-#[macro_export]
-macro_rules! vec {
- ($($x:expr),*) => ({
- let xs: ::std::boxed::Box<[_]> = box [$($x),*];
- ::std::slice::SliceExt::into_vec(xs)
- });
- ($($x:expr,)*) => (vec![$($x),*])
-}
-
-/// A macro to select an event from a number of receivers.
-///
-/// This macro is used to wait for the first event to occur on a number of
-/// receivers. It places no restrictions on the types of receivers given to
-/// this macro, this can be viewed as a heterogeneous select.
-///
-/// # Example
-///
-/// ```
-/// use std::thread::Thread;
-/// use std::sync::mpsc::channel;
-///
-/// let (tx1, rx1) = channel();
-/// let (tx2, rx2) = channel();
-/// # fn long_running_task() {}
-/// # fn calculate_the_answer() -> int { 42i }
-///
-/// Thread::spawn(move|| { long_running_task(); tx1.send(()) }).detach();
-/// Thread::spawn(move|| { tx2.send(calculate_the_answer()) }).detach();
-///
-/// select! (
-/// _ = rx1.recv() => println!("the long running task finished first"),
-/// answer = rx2.recv() => {
-/// println!("the answer was: {}", answer.unwrap());
-/// }
-/// )
-/// ```
-///
-/// For more information about select, see the `std::sync::mpsc::Select` structure.
-#[macro_export]
-#[experimental]
-macro_rules! select {
- (
- $($name:pat = $rx:ident.$meth:ident() => $code:expr),+
- ) => ({
- use std::sync::mpsc::Select;
- let sel = Select::new();
- $( let mut $rx = sel.handle(&$rx); )+
- unsafe {
- $( $rx.add(); )+
- }
- let ret = sel.wait();
- $( if ret == $rx.id() { let $name = $rx.$meth(); $code } else )+
- { unreachable!() }
- })
-}
-
-// When testing the standard library, we link to the liblog crate to get the
-// logging macros. In doing so, the liblog crate was linked against the real
-// version of libstd, and uses a different std::fmt module than the test crate
-// uses. To get around this difference, we redefine the log!() macro here to be
-// just a dumb version of what it should be.
-#[cfg(test)]
-macro_rules! log {
- ($lvl:expr, $($args:tt)*) => (
- if log_enabled!($lvl) { println!($($args)*) }
- )
-}
-
-/// Built-in macros to the compiler itself.
-///
-/// These macros do not have any corresponding definition with a `macro_rules!`
-/// macro, but are documented here. Their implementations can be found hardcoded
-/// into libsyntax itself.
-#[cfg(dox)]
-pub mod builtin {
- /// The core macro for formatted string creation & output.
- ///
- /// This macro produces a value of type `fmt::Arguments`. This value can be
- /// passed to the functions in `std::fmt` for performing useful functions.
- /// All other formatting macros (`format!`, `write!`, `println!`, etc) are
- /// proxied through this one.
- ///
- /// For more information, see the documentation in `std::fmt`.
- ///
- /// # Example
- ///
- /// ```rust
- /// use std::fmt;
- ///
- /// let s = fmt::format(format_args!("hello {}", "world"));
- /// assert_eq!(s, format!("hello {}", "world"));
- ///
- /// ```
- #[macro_export]
- macro_rules! format_args { ($fmt:expr $($args:tt)*) => ({
- /* compiler built-in */
- }) }
-
- /// Inspect an environment variable at compile time.
- ///
- /// This macro will expand to the value of the named environment variable at
- /// compile time, yielding an expression of type `&'static str`.
- ///
- /// If the environment variable is not defined, then a compilation error
- /// will be emitted. To not emit a compile error, use the `option_env!`
- /// macro instead.
- ///
- /// # Example
- ///
- /// ```rust
- /// let path: &'static str = env!("PATH");
- /// println!("the $PATH variable at the time of compiling was: {}", path);
- /// ```
- #[macro_export]
- macro_rules! env { ($name:expr) => ({ /* compiler built-in */ }) }
-
- /// Optionally inspect an environment variable at compile time.
- ///
- /// If the named environment variable is present at compile time, this will
- /// expand into an expression of type `Option<&'static str>` whose value is
- /// `Some` of the value of the environment variable. If the environment
- /// variable is not present, then this will expand to `None`.
- ///
- /// A compile time error is never emitted when using this macro regardless
- /// of whether the environment variable is present or not.
- ///
- /// # Example
- ///
- /// ```rust
- /// let key: Option<&'static str> = option_env!("SECRET_KEY");
- /// println!("the secret key might be: {}", key);
- /// ```
- #[macro_export]
- macro_rules! option_env { ($name:expr) => ({ /* compiler built-in */ }) }
-
- /// Concatenate literals into a static byte slice.
- ///
- /// This macro takes any number of comma-separated literal expressions,
- /// yielding an expression of type `&'static [u8]` which is the
- /// concatenation (left to right) of all the literals in their byte format.
- ///
- /// This extension currently only supports string literals, character
- /// literals, and integers less than 256. The byte slice returned is the
- /// utf8-encoding of strings and characters.
- ///
- /// # Example
- ///
- /// ```
- /// let rust = bytes!("r", 'u', "st", 255);
- /// assert_eq!(rust[1], b'u');
- /// assert_eq!(rust[4], 255);
- /// ```
- #[macro_export]
- macro_rules! bytes { ($($e:expr),*) => ({ /* compiler built-in */ }) }
-
- /// Concatenate identifiers into one identifier.
- ///
- /// This macro takes any number of comma-separated identifiers, and
- /// concatenates them all into one, yielding an expression which is a new
- /// identifier. Note that hygiene makes it such that this macro cannot
- /// capture local variables, and macros are only allowed in item,
- /// statement or expression position, meaning this macro may be difficult to
- /// use in some situations.
- ///
- /// # Example
- ///
- /// ```
- /// #![feature(concat_idents)]
- ///
- /// # fn main() {
- /// fn foobar() -> int { 23 }
- ///
- /// let f = concat_idents!(foo, bar);
- /// println!("{}", f());
- /// # }
- /// ```
- #[macro_export]
- macro_rules! concat_idents {
- ($($e:ident),*) => ({ /* compiler built-in */ })
- }
-
- /// Concatenates literals into a static string slice.
- ///
- /// This macro takes any number of comma-separated literals, yielding an
- /// expression of type `&'static str` which represents all of the literals
- /// concatenated left-to-right.
- ///
- /// Integer and floating point literals are stringified in order to be
- /// concatenated.
- ///
- /// # Example
- ///
- /// ```
- /// let s = concat!("test", 10i, 'b', true);
- /// assert_eq!(s, "test10btrue");
- /// ```
- #[macro_export]
- macro_rules! concat { ($($e:expr),*) => ({ /* compiler built-in */ }) }
-
- /// A macro which expands to the line number on which it was invoked.
- ///
- /// The expanded expression has type `uint`, and the returned line is not
- /// the invocation of the `line!()` macro itself, but rather the first macro
- /// invocation leading up to the invocation of the `line!()` macro.
- ///
- /// # Example
- ///
- /// ```
- /// let current_line = line!();
- /// println!("defined on line: {}", current_line);
- /// ```
- #[macro_export]
- macro_rules! line { () => ({ /* compiler built-in */ }) }
-
- /// A macro which expands to the column number on which it was invoked.
- ///
- /// The expanded expression has type `uint`, and the returned column is not
- /// the invocation of the `column!()` macro itself, but rather the first macro
- /// invocation leading up to the invocation of the `column!()` macro.
- ///
- /// # Example
- ///
- /// ```
- /// let current_col = column!();
- /// println!("defined on column: {}", current_col);
- /// ```
- #[macro_export]
- macro_rules! column { () => ({ /* compiler built-in */ }) }
-
- /// A macro which expands to the file name from which it was invoked.
- ///
- /// The expanded expression has type `&'static str`, and the returned file
- /// is not the invocation of the `file!()` macro itself, but rather the
- /// first macro invocation leading up to the invocation of the `file!()`
- /// macro.
- ///
- /// # Example
- ///
- /// ```
- /// let this_file = file!();
- /// println!("defined in file: {}", this_file);
- /// ```
- #[macro_export]
- macro_rules! file { () => ({ /* compiler built-in */ }) }
-
- /// A macro which stringifies its argument.
- ///
- /// This macro will yield an expression of type `&'static str` which is the
- /// stringification of all the tokens passed to the macro. No restrictions
- /// are placed on the syntax of the macro invocation itself.
- ///
- /// # Example
- ///
- /// ```
- /// let one_plus_one = stringify!(1 + 1);
- /// assert_eq!(one_plus_one, "1 + 1");
- /// ```
- #[macro_export]
- macro_rules! stringify { ($t:tt) => ({ /* compiler built-in */ }) }
-
- /// Includes a utf8-encoded file as a string.
- ///
- /// This macro will yield an expression of type `&'static str` which is the
- /// contents of the filename specified. The file is located relative to the
- /// current file (similarly to how modules are found),
- ///
- /// # Example
- ///
- /// ```rust,ignore
- /// let secret_key = include_str!("secret-key.ascii");
- /// ```
- #[macro_export]
- macro_rules! include_str { ($file:expr) => ({ /* compiler built-in */ }) }
-
- /// Includes a file as a byte slice.
- ///
- /// This macro will yield an expression of type `&'static [u8]` which is
- /// the contents of the filename specified. The file is located relative to
- /// the current file (similarly to how modules are found),
- ///
- /// # Example
- ///
- /// ```rust,ignore
- /// let secret_key = include_bytes!("secret-key.bin");
- /// ```
- #[macro_export]
- macro_rules! include_bytes { ($file:expr) => ({ /* compiler built-in */ }) }
-
- /// Deprecated alias for `include_bytes!()`.
- #[macro_export]
- macro_rules! include_bin { ($file:expr) => ({ /* compiler built-in */}) }
-
- /// Expands to a string that represents the current module path.
- ///
- /// The current module path can be thought of as the hierarchy of modules
- /// leading back up to the crate root. The first component of the path
- /// returned is the name of the crate currently being compiled.
- ///
- /// # Example
- ///
- /// ```rust
- /// mod test {
- /// pub fn foo() {
- /// assert!(module_path!().ends_with("test"));
- /// }
- /// }
- ///
- /// test::foo();
- /// ```
- #[macro_export]
- macro_rules! module_path { () => ({ /* compiler built-in */ }) }
-
- /// Boolean evaluation of configuration flags.
- ///
- /// In addition to the `#[cfg]` attribute, this macro is provided to allow
- /// boolean expression evaluation of configuration flags. This frequently
- /// leads to less duplicated code.
- ///
- /// The syntax given to this macro is the same syntax as the `cfg`
- /// attribute.
- ///
- /// # Example
- ///
- /// ```rust
- /// let my_directory = if cfg!(windows) {
- /// "windows-specific-directory"
- /// } else {
- /// "unix-directory"
- /// };
- /// ```
- #[macro_export]
- macro_rules! cfg { ($cfg:tt) => ({ /* compiler built-in */ }) }
-}
#[cfg(test)] use fmt::Show;
use ops::{Add, Sub, Mul, Div, Rem, Neg};
-use kinds::Copy;
+use marker::Copy;
use clone::Clone;
use cmp::{PartialOrd, PartialEq};
use fmt;
use io::{IoResult, IoError};
use iter::{Iterator, IteratorExt};
-use kinds::Copy;
+use marker::Copy;
use libc::{c_void, c_int, c_char};
use libc;
use boxed::Box;
///
/// // We assume that we are in a valid directory.
/// let current_working_directory = os::getcwd().unwrap();
-/// println!("The current directory is {}", current_working_directory.display());
+/// println!("The current directory is {:?}", current_working_directory.display());
/// ```
pub fn getcwd() -> IoResult<Path> {
sys::os::getcwd()
impl Error for MapError {
fn description(&self) -> &str { "memory map error" }
- fn detail(&self) -> Option<String> { Some(self.to_string()) }
+ fn detail(&self) -> Option<String> { Some(format!("{:?}", self)) }
}
impl FromError<MapError> for Box<Error> {
os::MapOption::MapWritable
]) {
Ok(chunk) => chunk,
- Err(msg) => panic!("{}", msg)
+ Err(msg) => panic!("{:?}", msg)
};
assert!(chunk.len >= 16);
#![experimental]
-use core::kinds::Sized;
+use core::marker::Sized;
use ffi::CString;
use clone::Clone;
use fmt;
use iter::IteratorExt;
use option::Option;
use option::Option::{None, Some};
+use ops::{FullRange, Index};
use str;
use str::StrExt;
use string::{String, CowString};
match name.rposition_elem(&dot) {
None | Some(0) => name,
Some(1) if name == b".." => name,
- Some(pos) => name[..pos]
+ Some(pos) => name.index(&(0..pos))
}
})
}
match name.rposition_elem(&dot) {
None | Some(0) => None,
Some(1) if name == b".." => None,
- Some(pos) => Some(name[pos+1..])
+ Some(pos) => Some(name.index(&((pos+1)..)))
}
}
}
/// # #[cfg(unix)] fn foo() {
/// let mut p = Path::new("abc/def.txt");
/// p.set_extension("csv");
- /// assert!(p == Path::new("abc/def.csv"));
+ /// assert_eq!(p, Path::new("abc/def.csv"));
/// # }
/// ```
///
let extlen = extension.container_as_bytes().len();
match (name.rposition_elem(&dot), extlen) {
(None, 0) | (Some(0), 0) => None,
- (Some(idx), 0) => Some(name[..idx].to_vec()),
+ (Some(idx), 0) => Some(name.index(&(0..idx)).to_vec()),
(idx, extlen) => {
let idx = match idx {
None | Some(0) => name.len(),
let mut v;
v = Vec::with_capacity(idx + extlen + 1);
- v.push_all(name[..idx]);
+ v.push_all(name.index(&(0..idx)));
v.push(dot);
v.push_all(extension.container_as_bytes());
Some(v)
/// # #[cfg(windows)] fn foo() {}
/// # #[cfg(unix)] fn foo() {
/// let mut p = Path::new("abc/def.txt");
- /// assert!(p.with_filename("foo.dat") == Path::new("abc/foo.dat"));
+ /// assert_eq!(p.with_filename("foo.dat"), Path::new("abc/foo.dat"));
/// # }
/// ```
///
/// # #[cfg(windows)] fn foo() {}
/// # #[cfg(unix)] fn foo() {
/// let mut p = Path::new("abc/def.txt");
- /// assert!(p.with_extension("csv") == Path::new("abc/def.csv"));
+ /// assert_eq!(p.with_extension("csv"), Path::new("abc/def.csv"));
/// # }
/// ```
///
/// # #[cfg(windows)] fn foo() {}
/// # #[cfg(unix)] fn foo() {
/// let p = Path::new("abc/def/ghi");
- /// assert!(p.dir_path() == Path::new("abc/def"));
+ /// assert_eq!(p.dir_path(), Path::new("abc/def"));
/// # }
/// ```
fn dir_path(&self) -> Self {
/// # foo();
/// # #[cfg(windows)] fn foo() {}
/// # #[cfg(unix)] fn foo() {
- /// assert!(Path::new("abc/def").root_path() == None);
- /// assert!(Path::new("/abc/def").root_path() == Some(Path::new("/")));
+ /// assert_eq!(Path::new("abc/def").root_path(), None);
+ /// assert_eq!(Path::new("/abc/def").root_path(), Some(Path::new("/")));
/// # }
/// ```
fn root_path(&self) -> Option<Self>;
/// # #[cfg(unix)] fn foo() {
/// let mut p = Path::new("foo/bar");
/// p.push("baz.txt");
- /// assert!(p == Path::new("foo/bar/baz.txt"));
+ /// assert_eq!(p, Path::new("foo/bar/baz.txt"));
/// # }
/// ```
///
/// # #[cfg(unix)] fn foo() {
/// let mut p = Path::new("foo");
/// p.push_many(&["bar", "baz.txt"]);
- /// assert!(p == Path::new("foo/bar/baz.txt"));
+ /// assert_eq!(p, Path::new("foo/bar/baz.txt"));
/// # }
/// ```
#[inline]
/// # #[cfg(unix)] fn foo() {
/// let mut p = Path::new("foo/bar/baz.txt");
/// p.pop();
- /// assert!(p == Path::new("foo/bar"));
+ /// assert_eq!(p, Path::new("foo/bar"));
/// # }
/// ```
fn pop(&mut self) -> bool;
/// # #[cfg(windows)] fn foo() {}
/// # #[cfg(unix)] fn foo() {
/// let p = Path::new("/foo");
- /// assert!(p.join("bar.txt") == Path::new("/foo/bar.txt"));
+ /// assert_eq!(p.join("bar.txt"), Path::new("/foo/bar.txt"));
/// # }
/// ```
///
/// # #[cfg(unix)] fn foo() {
/// let p = Path::new("foo");
/// let fbbq = Path::new("foo/bar/baz/quux.txt");
- /// assert!(p.join_many(&["bar", "baz", "quux.txt"]) == fbbq);
+ /// assert_eq!(p.join_many(&["bar", "baz", "quux.txt"]), fbbq);
/// # }
/// ```
#[inline]
/// let p = Path::new("foo/bar/baz/quux.txt");
/// let fb = Path::new("foo/bar");
/// let bq = Path::new("baz/quux.txt");
- /// assert!(p.path_relative_from(&fb) == Some(bq));
+ /// assert_eq!(p.path_relative_from(&fb), Some(bq));
/// # }
/// ```
fn path_relative_from(&self, base: &Self) -> Option<Self>;
filename: bool
}
+//NOTE(stage0): replace with deriving(Show) after snapshot
impl<'a, P: GenericPath> fmt::Show for Display<'a, P> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl<'a, P: GenericPath> fmt::String for Display<'a, P> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.as_cow().fmt(f)
}
}
#[inline]
fn container_as_str(&self) -> Option<&str> {
- Some(self[])
+ Some(self.index(&FullRange))
}
#[inline]
fn is_str(_: Option<&String>) -> bool { true }
impl BytesContainer for Vec<u8> {
#[inline]
fn container_as_bytes(&self) -> &[u8] {
- self[]
+ self.index(&FullRange)
}
}
use clone::Clone;
use cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd};
+use fmt;
use hash;
use io::Writer;
use iter::{AdditiveIterator, Extend};
use iter::{Iterator, IteratorExt, Map};
-use kinds::Sized;
+use ops::Index;
+use marker::Sized;
use option::Option::{self, Some, None};
use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
use str::{self, FromStr, StrExt};
c == SEP
}
+impl fmt::Show for Path {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "Path {{ {} }}", self.display())
+ }
+}
+
impl PartialEq for Path {
#[inline]
fn eq(&self, other: &Path) -> bool {
None => {
self.repr = Path::normalize(filename);
}
- Some(idx) if self.repr[idx+1..] == b".." => {
+ Some(idx) if self.repr.index(&((idx+1)..)) == b".." => {
let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len());
v.push_all(self.repr.as_slice());
v.push(SEP_BYTE);
}
Some(idx) => {
let mut v = Vec::with_capacity(idx + 1 + filename.len());
- v.push_all(self.repr[..idx+1]);
+ v.push_all(self.repr.index(&(0..(idx+1))));
v.push_all(filename);
// FIXME: this is slow
self.repr = Path::normalize(v.as_slice());
match self.sepidx {
None if b".." == self.repr => self.repr.as_slice(),
None => dot_static,
- Some(0) => self.repr[..1],
- Some(idx) if self.repr[idx+1..] == b".." => self.repr.as_slice(),
- Some(idx) => self.repr[..idx]
+ Some(0) => self.repr.index(&(0..1)),
+ Some(idx) if self.repr.index(&((idx+1)..)) == b".." => self.repr.as_slice(),
+ Some(idx) => self.repr.index(&(0..idx))
}
}
None if b"." == self.repr ||
b".." == self.repr => None,
None => Some(self.repr.as_slice()),
- Some(idx) if self.repr[idx+1..] == b".." => None,
- Some(0) if self.repr[1..].is_empty() => None,
- Some(idx) => Some(self.repr[idx+1..])
+ Some(idx) if self.repr.index(&((idx+1)..)) == b".." => None,
+ Some(0) if self.repr.index(&(1..)).is_empty() => None,
+ Some(idx) => Some(self.repr.index(&((idx+1)..)))
}
}
// borrowck is being very picky
let val = {
let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;
- let v_ = if is_abs { v.as_slice()[1..] } else { v.as_slice() };
+ let v_ = if is_abs { v.as_slice().index(&(1..)) } else { v.as_slice() };
let comps = normalize_helper(v_, is_abs);
match comps {
None => None,
/// A path of "/" yields no components. A path of "." yields one component.
pub fn components<'a>(&'a self) -> Components<'a> {
let v = if self.repr[0] == SEP_BYTE {
- self.repr[1..]
+ self.repr.index(&(1..))
} else { self.repr.as_slice() };
let is_sep_byte: fn(&u8) -> bool = is_sep_byte; // coerce to fn ptr
let mut ret = v.split(is_sep_byte);
(s: $path:expr, $exp:expr) => (
{
let path = $path;
- assert!(path.as_str() == Some($exp));
+ assert_eq!(path.as_str(), Some($exp));
}
);
(v: $path:expr, $exp:expr) => (
{
let path = $path;
- assert!(path.as_vec() == $exp);
+ assert_eq!(path.as_vec(), $exp);
}
)
}
t!(v: Path::new(b"a/b/c\xFF"), b"a/b/c\xFF");
t!(v: Path::new(b"\xFF/../foo\x80"), b"foo\x80");
let p = Path::new(b"a/b/c\xFF");
- assert!(p.as_str() == None);
+ assert!(p.as_str().is_none());
t!(s: Path::new(""), ".");
t!(s: Path::new("/"), "/");
b"/bar");
let p = Path::new(b"foo/bar\x80");
- assert!(p.as_str() == None);
+ assert!(p.as_str().is_none());
}
#[test]
fn test_opt_paths() {
- assert!(Path::new_opt(b"foo/bar\0") == None);
+ assert!(Path::new_opt(b"foo/bar\0").is_none());
t!(v: Path::new_opt(b"foo/bar").unwrap(), b"foo/bar");
- assert!(Path::new_opt("foo/bar\0") == None);
+ assert!(Path::new_opt("foo/bar\0").is_none());
t!(s: Path::new_opt("foo/bar").unwrap(), "foo/bar");
}
#[test]
fn test_null_byte() {
use thread::Thread;
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new(b"foo/bar\0")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new("test").set_filename(b"f\0o")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new("test").push(b"f\0o");
}).join();
assert!(result.is_err());
($path:expr, $disp:ident, $exp:expr) => (
{
let path = Path::new($path);
- assert!(path.$disp().to_string() == $exp);
+ assert_eq!(path.$disp().to_string(), $exp);
}
)
}
{
let path = Path::new($path);
let mo = path.display().as_cow();
- assert!(mo.as_slice() == $exp);
+ assert_eq!(mo.as_slice(), $exp);
}
);
($path:expr, $exp:expr, filename) => (
{
let path = Path::new($path);
let mo = path.filename_display().as_cow();
- assert!(mo.as_slice() == $exp);
+ assert_eq!(mo.as_slice(), $exp);
}
)
}
{
let path = Path::new($path);
let f = format!("{}", path.display());
- assert!(f == $exp);
+ assert_eq!(f, $exp);
let f = format!("{}", path.filename_display());
- assert!(f == $expf);
+ assert_eq!(f, $expf);
}
)
}
(s: $path:expr, $op:ident, $exp:expr) => (
{
let path = Path::new($path);
- assert!(path.$op() == ($exp).as_bytes());
+ assert_eq!(path.$op(), ($exp).as_bytes());
}
);
(s: $path:expr, $op:ident, $exp:expr, opt) => (
{
let path = Path::new($path);
let left = path.$op().map(|x| str::from_utf8(x).unwrap());
- assert!(left == $exp);
+ assert_eq!(left, $exp);
}
);
(v: $path:expr, $op:ident, $exp:expr) => (
{
let arg = $path;
let path = Path::new(arg);
- assert!(path.$op() == $exp);
+ assert_eq!(path.$op(), $exp);
}
);
}
let mut p1 = Path::new(path);
let p2 = p1.clone();
p1.push(join);
- assert!(p1 == p2.join(join));
+ assert_eq!(p1, p2.join(join));
}
)
}
let mut p = Path::new($path);
let push = Path::new($push);
p.push(&push);
- assert!(p.as_str() == Some($exp));
+ assert_eq!(p.as_str(), Some($exp));
}
)
}
{
let mut p = Path::new($path);
p.push_many(&$push);
- assert!(p.as_str() == Some($exp));
+ assert_eq!(p.as_str(), Some($exp));
}
);
(v: $path:expr, $push:expr, $exp:expr) => (
{
let mut p = Path::new($path);
p.push_many(&$push);
- assert!(p.as_vec() == $exp);
+ assert_eq!(p.as_vec(), $exp);
}
)
}
{
let mut p = Path::new($path);
let result = p.pop();
- assert!(p.as_str() == Some($left));
- assert!(result == $right);
+ assert_eq!(p.as_str(), Some($left));
+ assert_eq!(result, $right);
}
);
(b: $path:expr, $left:expr, $right:expr) => (
{
let mut p = Path::new($path);
let result = p.pop();
- assert!(p.as_vec() == $left);
- assert!(result == $right);
+ assert_eq!(p.as_vec(), $left);
+ assert_eq!(result, $right);
}
)
}
#[test]
fn test_root_path() {
- assert!(Path::new(b"a/b/c").root_path() == None);
- assert!(Path::new(b"/a/b/c").root_path() == Some(Path::new("/")));
+ assert_eq!(Path::new(b"a/b/c").root_path(), None);
+ assert_eq!(Path::new(b"/a/b/c").root_path(), Some(Path::new("/")));
}
#[test]
let path = Path::new($path);
let join = Path::new($join);
let res = path.join(&join);
- assert!(res.as_str() == Some($exp));
+ assert_eq!(res.as_str(), Some($exp));
}
)
}
{
let path = Path::new($path);
let res = path.join_many(&$join);
- assert!(res.as_str() == Some($exp));
+ assert_eq!(res.as_str(), Some($exp));
}
);
(v: $path:expr, $join:expr, $exp:expr) => (
{
let path = Path::new($path);
let res = path.join_many(&$join);
- assert!(res.as_vec() == $exp);
+ assert_eq!(res.as_vec(), $exp);
}
)
}
let mut p1 = Path::new(path);
p1.$set(arg);
let p2 = Path::new(path);
- assert!(p1 == p2.$with(arg));
+ assert_eq!(p1, p2.$with(arg));
}
);
(v: $path:expr, $set:ident, $with:ident, $arg:expr) => (
let mut p1 = Path::new(path);
p1.$set(arg);
let p2 = Path::new(path);
- assert!(p1 == p2.$with(arg));
+ assert_eq!(p1, p2.$with(arg));
}
)
}
(s: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
{
let path = $path;
- let filename = $filename;
- assert!(path.filename_str() == filename,
- "{}.filename_str(): Expected `{}`, found {}",
- path.as_str().unwrap(), filename, path.filename_str());
- let dirname = $dirname;
- assert!(path.dirname_str() == dirname,
- "`{}`.dirname_str(): Expected `{}`, found `{}`",
- path.as_str().unwrap(), dirname, path.dirname_str());
- let filestem = $filestem;
- assert!(path.filestem_str() == filestem,
- "`{}`.filestem_str(): Expected `{}`, found `{}`",
- path.as_str().unwrap(), filestem, path.filestem_str());
- let ext = $ext;
- assert!(path.extension_str() == ext,
- "`{}`.extension_str(): Expected `{}`, found `{}`",
- path.as_str().unwrap(), ext, path.extension_str());
- }
+ assert_eq!(path.filename_str(), $filename);
+ assert_eq!(path.dirname_str(), $dirname);
+ assert_eq!(path.filestem_str(), $filestem);
+ assert_eq!(path.extension_str(), $ext);
+ }
);
(v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
{
let path = $path;
- assert!(path.filename() == $filename);
- assert!(path.dirname() == $dirname);
- assert!(path.filestem() == $filestem);
- assert!(path.extension() == $ext);
+ assert_eq!(path.filename(), $filename);
+ assert_eq!(path.dirname(), $dirname);
+ assert_eq!(path.filestem(), $filestem);
+ assert_eq!(path.extension(), $ext);
}
)
}
let comps = path.components().collect::<Vec<&[u8]>>();
let exp: &[&str] = &$exp;
let exps = exp.iter().map(|x| x.as_bytes()).collect::<Vec<&[u8]>>();
- assert!(comps == exps, "components: Expected {}, found {}",
- comps, exps);
+ assert_eq!(comps, exps);
let comps = path.components().rev().collect::<Vec<&[u8]>>();
let exps = exps.into_iter().rev().collect::<Vec<&[u8]>>();
- assert!(comps == exps, "rev_components: Expected {}, found {}",
- comps, exps);
+ assert_eq!(comps, exps);
}
);
(b: $arg:expr, [$($exp:expr),*]) => (
use char::CharExt;
use clone::Clone;
use cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd};
+use fmt;
use hash;
use io::Writer;
use iter::{AdditiveIterator, Extend};
use iter::{Iterator, IteratorExt, Map, repeat};
use mem;
use option::Option::{self, Some, None};
+use ops::{FullRange, Index};
use slice::{SliceExt, SliceConcatExt};
use str::{SplitTerminator, FromStr, StrExt};
use string::{String, ToString};
sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr
}
+impl fmt::Show for Path {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "Path {{ {} }}", self.display())
+ }
+}
+
impl PartialEq for Path {
#[inline]
fn eq(&self, other: &Path) -> bool {
s.push_str("..");
s.push(SEP);
s.push_str(filename);
- self.update_normalized(s[]);
+ self.update_normalized(s.index(&FullRange));
}
None => {
self.update_normalized(filename);
}
- Some((_,idxa,end)) if self.repr[idxa..end] == ".." => {
+ Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
let mut s = String::with_capacity(end + 1 + filename.len());
- s.push_str(self.repr[0..end]);
+ s.push_str(self.repr.index(&(0..end)));
s.push(SEP);
s.push_str(filename);
- self.update_normalized(s[]);
+ self.update_normalized(s.index(&FullRange));
}
Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
let mut s = String::with_capacity(idxb + filename.len());
- s.push_str(self.repr[0..idxb]);
+ s.push_str(self.repr.index(&(0..idxb)));
s.push_str(filename);
- self.update_normalized(s[]);
+ self.update_normalized(s.index(&FullRange));
}
Some((idxb,_,_)) => {
let mut s = String::with_capacity(idxb + 1 + filename.len());
- s.push_str(self.repr[0..idxb]);
+ s.push_str(self.repr.index(&(0..idxb)));
s.push(SEP);
s.push_str(filename);
- self.update_normalized(s[]);
+ self.update_normalized(s.index(&FullRange));
}
}
}
let path = path.container_as_str().unwrap();
fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool {
// assume prefix is Some(DiskPrefix)
- let rest = path[prefix_len(prefix)..];
+ let rest = path.index(&(prefix_len(prefix)..));
!rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char)
}
fn shares_volume(me: &Path, path: &str) -> bool {
// path is assumed to have a prefix of Some(DiskPrefix)
- let repr = me.repr[];
+ let repr = me.repr.index(&FullRange);
match me.prefix {
Some(DiskPrefix) => {
repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase()
else { None };
let pathlen = path_.as_ref().map_or(path.len(), |p| p.len());
let mut s = String::with_capacity(me.repr.len() + 1 + pathlen);
- s.push_str(me.repr[]);
+ s.push_str(me.repr.index(&FullRange));
let plen = me.prefix_len();
// if me is "C:" we don't want to add a path separator
match me.prefix {
}
match path_ {
None => s.push_str(path),
- Some(p) => s.push_str(p[]),
+ Some(p) => s.push_str(p.index(&FullRange)),
};
- me.update_normalized(s[])
+ me.update_normalized(s.index(&FullRange))
}
if !path.is_empty() {
match prefix {
Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => {
// cwd-relative path, self is on the same volume
- append_path(self, path[prefix_len(prefix)..]);
+ append_path(self, path.index(&(prefix_len(prefix)..)));
}
Some(_) => {
// absolute path, or cwd-relative and self is not same volume
/// Always returns a `Some` value.
#[inline]
fn as_str<'a>(&'a self) -> Option<&'a str> {
- Some(self.repr[])
+ Some(self.repr.index(&FullRange))
}
#[inline]
/// Always returns a `Some` value.
fn dirname_str<'a>(&'a self) -> Option<&'a str> {
Some(match self.sepidx_or_prefix_len() {
- None if ".." == self.repr => self.repr[],
+ None if ".." == self.repr => self.repr.index(&FullRange),
None => ".",
- Some((_,idxa,end)) if self.repr[idxa..end] == ".." => self.repr[],
- Some((idxb,_,end)) if self.repr[idxb..end] == "\\" => self.repr[],
- Some((0,idxa,_)) => self.repr[0..idxa],
+ Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
+ self.repr.index(&FullRange)
+ }
+ Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => {
+ self.repr.index(&FullRange)
+ }
+ Some((0,idxa,_)) => self.repr.index(&(0..idxa)),
Some((idxb,idxa,_)) => {
match self.prefix {
Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
- self.repr[0..idxa]
+ self.repr.index(&(0..idxa))
}
- _ => self.repr[0..idxb]
+ _ => self.repr.index(&(0..idxb))
}
}
})
/// See `GenericPath::filename_str` for info.
/// Always returns a `Some` value if `filename` returns a `Some` value.
fn filename_str<'a>(&'a self) -> Option<&'a str> {
- let repr = self.repr[];
+ let repr = self.repr.index(&FullRange);
match self.sepidx_or_prefix_len() {
None if "." == repr || ".." == repr => None,
None => Some(repr),
- Some((_,idxa,end)) if repr[idxa..end] == ".." => None,
+ Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None,
Some((_,idxa,end)) if idxa == end => None,
- Some((_,idxa,end)) => Some(repr[idxa..end])
+ Some((_,idxa,end)) => Some(repr.index(&(idxa..end)))
}
}
true
}
Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
- Some((idxb,_,end)) if self.repr[idxb..end] == "\\" => false,
+ Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false,
Some((idxb,idxa,_)) => {
let trunc = match self.prefix {
Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
if self.prefix.is_some() {
Some(Path::new(match self.prefix {
Some(DiskPrefix) if self.is_absolute() => {
- self.repr[0..self.prefix_len()+1]
+ self.repr.index(&(0..(self.prefix_len()+1)))
}
Some(VerbatimDiskPrefix) => {
- self.repr[0..self.prefix_len()+1]
+ self.repr.index(&(0..(self.prefix_len()+1)))
}
- _ => self.repr[0..self.prefix_len()]
+ _ => self.repr.index(&(0..self.prefix_len()))
}))
} else if is_vol_relative(self) {
- Some(Path::new(self.repr[0..1]))
+ Some(Path::new(self.repr.index(&(0..1))))
} else {
None
}
fn is_absolute(&self) -> bool {
match self.prefix {
Some(DiskPrefix) => {
- let rest = self.repr[self.prefix_len()..];
+ let rest = self.repr.index(&(self.prefix_len()..));
rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE
}
Some(_) => true,
/// Does not distinguish between absolute and cwd-relative paths, e.g.
/// C:\foo and C:foo.
pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
- let repr = self.repr[];
+ let repr = self.repr.index(&FullRange);
let s = match self.prefix {
Some(_) => {
let plen = self.prefix_len();
if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE {
- repr[plen+1..]
- } else { repr[plen..] }
+ repr.index(&((plen+1)..))
+ } else { repr.index(&(plen..)) }
}
- None if repr.as_bytes()[0] == SEP_BYTE => repr[1..],
+ None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)),
None => repr
};
let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr
}
fn equiv_prefix(&self, other: &Path) -> bool {
- let s_repr = self.repr[];
- let o_repr = other.repr[];
+ let s_repr = self.repr.index(&FullRange);
+ let o_repr = other.repr.index(&FullRange);
match (self.prefix, other.prefix) {
(Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
self.is_absolute() &&
o_repr.as_bytes()[4].to_ascii_lowercase()
}
(Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
- s_repr[2..self.prefix_len()] == o_repr[8..other.prefix_len()]
+ s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len()))
}
(Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => {
- s_repr[8..self.prefix_len()] == o_repr[2..other.prefix_len()]
+ s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len()))
}
(None, None) => true,
(a, b) if a == b => {
- s_repr[0..self.prefix_len()] == o_repr[0..other.prefix_len()]
+ s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len()))
}
_ => false
}
match prefix.unwrap() {
DiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
- let mut s = String::from_str(s[0..len]);
+ let mut s = String::from_str(s.index(&(0..len)));
unsafe {
let v = s.as_mut_vec();
v[0] = (*v)[0].to_ascii_uppercase();
}
VerbatimDiskPrefix => {
let len = prefix_len(prefix) + is_abs as uint;
- let mut s = String::from_str(s[0..len]);
+ let mut s = String::from_str(s.index(&(0..len)));
unsafe {
let v = s.as_mut_vec();
v[4] = (*v)[4].to_ascii_uppercase();
_ => {
let plen = prefix_len(prefix);
if s.len() > plen {
- Some(String::from_str(s[0..plen]))
+ Some(String::from_str(s.index(&(0..plen))))
} else { None }
}
}
} else if is_abs && comps.is_empty() {
Some(repeat(SEP).take(1).collect())
} else {
- let prefix_ = s[0..prefix_len(prefix)];
+ let prefix_ = s.index(&(0..prefix_len(prefix)));
let n = prefix_.len() +
if is_abs { comps.len() } else { comps.len() - 1} +
comps.iter().map(|v| v.len()).sum();
s.push(':');
}
Some(VerbatimDiskPrefix) => {
- s.push_str(prefix_[0..4]);
+ s.push_str(prefix_.index(&(0..4)));
s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
- s.push_str(prefix_[5..]);
+ s.push_str(prefix_.index(&(5..)));
}
Some(UNCPrefix(a,b)) => {
s.push_str("\\\\");
- s.push_str(prefix_[2..a+2]);
+ s.push_str(prefix_.index(&(2..(a+2))));
s.push(SEP);
- s.push_str(prefix_[3+a..3+a+b]);
+ s.push_str(prefix_.index(&((3+a)..(3+a+b))));
}
Some(_) => s.push_str(prefix_),
None => ()
fn update_sepidx(&mut self) {
let s = if self.has_nonsemantic_trailing_slash() {
- self.repr[0..self.repr.len()-1]
- } else { self.repr[] };
+ self.repr.index(&(0..(self.repr.len()-1)))
+ } else { self.repr.index(&FullRange) };
let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) {
is_sep
} else {
/// non-verbatim, the non-verbatim version is returned.
/// Otherwise, None is returned.
pub fn make_non_verbatim(path: &Path) -> Option<Path> {
- let repr = path.repr[];
+ let repr = path.repr.index(&FullRange);
let new_path = match path.prefix {
Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None,
Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()),
Some(VerbatimDiskPrefix) => {
// \\?\D:\
- Path::new(repr[4..])
+ Path::new(repr.index(&(4..)))
}
Some(VerbatimUNCPrefix(_,_)) => {
// \\?\UNC\server\share
- Path::new(format!(r"\{}", repr[7..]))
+ Path::new(format!(r"\{}", repr.index(&(7..))))
}
};
if new_path.prefix.is_none() {
return None;
}
// now ensure normalization didn't change anything
- if repr[path.prefix_len()..] ==
- new_path.repr[new_path.prefix_len()..] {
+ if repr.index(&(path.prefix_len()..)) ==
+ new_path.repr.index(&(new_path.prefix_len()..)) {
Some(new_path)
} else {
None
fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
if path.starts_with("\\\\") {
// \\
- path = path[2..];
+ path = path.index(&(2..));
if path.starts_with("?\\") {
// \\?\
- path = path[2..];
+ path = path.index(&(2..));
if path.starts_with("UNC\\") {
// \\?\UNC\server\share
- path = path[4..];
+ path = path.index(&(4..));
let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) {
Some(x) => x,
None => (path.len(), 0)
}
} else if path.starts_with(".\\") {
// \\.\path
- path = path[2..];
+ path = path.index(&(2..));
let idx = path.find('\\').unwrap_or(path.len());
return Some(DeviceNSPrefix(idx));
}
None => return None,
Some(x) => x
};
- path = path[idx_a+1..];
+ path = path.index(&((idx_a+1)..));
let idx_b = path.find(f).unwrap_or(path.len());
Some((idx_a, idx_b))
}
is_sep_verbatim
};
let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix)));
- let s_ = s[prefix_len(prefix)..];
- let s_ = if is_abs { s_[1..] } else { s_ };
+ let s_ = s.index(&(prefix_len(prefix)..));
+ let s_ = if is_abs { s_.index(&(1..)) } else { s_ };
if is_abs && s_.is_empty() {
return (is_abs, match prefix {
(s: $path:expr, $exp:expr) => (
{
let path = $path;
- assert!(path.as_str() == Some($exp));
+ assert_eq!(path.as_str(), Some($exp));
}
);
(v: $path:expr, $exp:expr) => (
{
let path = $path;
- assert!(path.as_vec() == $exp);
+ assert_eq!(path.as_vec(), $exp);
}
)
}
let path = $path;
let exp = $exp;
let res = parse_prefix(path);
- assert!(res == exp,
- "parse_prefix(\"{}\"): expected {}, found {}", path, exp, res);
+ assert_eq!(res, exp);
}
)
}
#[test]
fn test_null_byte() {
use thread::Thread;
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new(b"foo/bar\0")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
Path::new("test").set_filename(b"f\0o")
}).join();
assert!(result.is_err());
- let result = Thread::spawn(move || {
+ let result = Thread::scoped(move || {
Path::new("test").push(b"f\0o");
}).join();
assert!(result.is_err());
{
let path = $path;
let path = Path::new(path);
- assert!(path.$op() == Some($exp));
+ assert_eq!(path.$op(), Some($exp));
}
);
(s: $path:expr, $op:ident, $exp:expr, opt) => (
let path = $path;
let path = Path::new(path);
let left = path.$op();
- assert!(left == $exp);
+ assert_eq!(left, $exp);
}
);
(v: $path:expr, $op:ident, $exp:expr) => (
{
let path = $path;
let path = Path::new(path);
- assert!(path.$op() == $exp);
+ assert_eq!(path.$op(), $exp);
}
)
}
let mut p1 = Path::new(path);
let p2 = p1.clone();
p1.push(join);
- assert!(p1 == p2.join(join));
+ assert_eq!(p1, p2.join(join));
}
)
}
// we do want to check one odd case though to ensure the prefix is re-parsed
let mut p = Path::new("\\\\?\\C:");
- assert!(prefix(&p) == Some(VerbatimPrefix(2)));
+ assert_eq!(prefix(&p), Some(VerbatimPrefix(2)));
p.push("foo");
- assert!(prefix(&p) == Some(VerbatimDiskPrefix));
+ assert_eq!(prefix(&p), Some(VerbatimDiskPrefix));
assert_eq!(p.as_str(), Some("\\\\?\\C:\\foo"));
// and another with verbatim non-normalized paths
let mut p = Path::new(pstr);
let result = p.pop();
let left = $left;
- assert!(p.as_str() == Some(left),
- "`{}`.pop() failed; expected remainder `{}`, found `{}`",
- pstr, left, p.as_str().unwrap());
- assert!(result == $right);
+ assert_eq!(p.as_str(), Some(left));
+ assert_eq!(result, $right);
}
);
(b: $path:expr, $left:expr, $right:expr) => (
let mut p = Path::new($path);
let result = p.pop();
assert_eq!(p.as_vec(), $left);
- assert!(result == $right);
+ assert_eq!(result, $right);
}
)
}
#[test]
fn test_root_path() {
- assert!(Path::new("a\\b\\c").root_path() == None);
- assert!(Path::new("\\a\\b\\c").root_path() == Some(Path::new("\\")));
- assert!(Path::new("C:a").root_path() == Some(Path::new("C:")));
- assert!(Path::new("C:\\a").root_path() == Some(Path::new("C:\\")));
- assert!(Path::new("\\\\a\\b\\c").root_path() == Some(Path::new("\\\\a\\b")));
- assert!(Path::new("\\\\?\\a\\b").root_path() == Some(Path::new("\\\\?\\a")));
- assert!(Path::new("\\\\?\\C:\\a").root_path() == Some(Path::new("\\\\?\\C:\\")));
- assert!(Path::new("\\\\?\\UNC\\a\\b\\c").root_path() ==
+ assert_eq!(Path::new("a\\b\\c").root_path(), None);
+ assert_eq!(Path::new("\\a\\b\\c").root_path(), Some(Path::new("\\")));
+ assert_eq!(Path::new("C:a").root_path(), Some(Path::new("C:")));
+ assert_eq!(Path::new("C:\\a").root_path(), Some(Path::new("C:\\")));
+ assert_eq!(Path::new("\\\\a\\b\\c").root_path(), Some(Path::new("\\\\a\\b")));
+ assert_eq!(Path::new("\\\\?\\a\\b").root_path(), Some(Path::new("\\\\?\\a")));
+ assert_eq!(Path::new("\\\\?\\C:\\a").root_path(), Some(Path::new("\\\\?\\C:\\")));
+ assert_eq!(Path::new("\\\\?\\UNC\\a\\b\\c").root_path(),
Some(Path::new("\\\\?\\UNC\\a\\b")));
- assert!(Path::new("\\\\.\\a\\b").root_path() == Some(Path::new("\\\\.\\a")));
+ assert_eq!(Path::new("\\\\.\\a\\b").root_path(), Some(Path::new("\\\\.\\a")));
}
#[test]
let path = Path::new(pstr);
let arg = $arg;
let res = path.$op(arg);
- let exp = $res;
- assert!(res.as_str() == Some(exp),
- "`{}`.{}(\"{}\"): Expected `{}`, found `{}`",
- pstr, stringify!($op), arg, exp, res.as_str().unwrap());
+ let exp = Path::new($res);
+ assert_eq!(res, exp);
}
)
}
let mut p1 = Path::new(path);
p1.$set(arg);
let p2 = Path::new(path);
- assert!(p1 == p2.$with(arg));
+ assert_eq!(p1, p2.$with(arg));
}
);
(v: $path:expr, $set:ident, $with:ident, $arg:expr) => (
let mut p1 = Path::new(path);
p1.$set(arg);
let p2 = Path::new(path);
- assert!(p1 == p2.$with(arg));
+ assert_eq!(p1, p2.$with(arg));
}
)
}
(s: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
{
let path = $path;
- let filename = $filename;
- assert!(path.filename_str() == filename,
- "`{}`.filename_str(): Expected `{}`, found `{}`",
- path.as_str().unwrap(), filename, path.filename_str());
- let dirname = $dirname;
- assert!(path.dirname_str() == dirname,
- "`{}`.dirname_str(): Expected `{}`, found `{}`",
- path.as_str().unwrap(), dirname, path.dirname_str());
- let filestem = $filestem;
- assert!(path.filestem_str() == filestem,
- "`{}`.filestem_str(): Expected `{}`, found `{}`",
- path.as_str().unwrap(), filestem, path.filestem_str());
- let ext = $ext;
- assert!(path.extension_str() == ext,
- "`{}`.extension_str(): Expected `{}`, found `{}`",
- path.as_str().unwrap(), ext, path.extension_str());
+ assert_eq!(path.filename_str(), $filename);
+ assert_eq!(path.dirname_str(), $dirname);
+ assert_eq!(path.filestem_str(), $filestem);
+ assert_eq!(path.extension_str(), $ext);
}
);
(v: $path:expr, $filename:expr, $dirname:expr, $filestem:expr, $ext:expr) => (
{
let path = $path;
- assert!(path.filename() == $filename);
- assert!(path.dirname() == $dirname);
- assert!(path.filestem() == $filestem);
- assert!(path.extension() == $ext);
+ assert_eq!(path.filename(), $filename);
+ assert_eq!(path.dirname(), $dirname);
+ assert_eq!(path.filestem(), $filestem);
+ assert_eq!(path.extension(), $ext);
}
)
}
{
let path = Path::new($path);
let (abs, vol, cwd, rel) = ($abs, $vol, $cwd, $rel);
- let b = path.is_absolute();
- assert!(b == abs, "Path '{}'.is_absolute(): expected {}, found {}",
- path.as_str().unwrap(), abs, b);
- let b = is_vol_relative(&path);
- assert!(b == vol, "is_vol_relative('{}'): expected {}, found {}",
- path.as_str().unwrap(), vol, b);
- let b = is_cwd_relative(&path);
- assert!(b == cwd, "is_cwd_relative('{}'): expected {}, found {}",
- path.as_str().unwrap(), cwd, b);
- let b = path.is_relative();
- assert!(b == rel, "Path '{}'.is_relativf(): expected {}, found {}",
- path.as_str().unwrap(), rel, b);
+ assert_eq!(path.is_absolute(), abs);
+ assert_eq!(is_vol_relative(&path), vol);
+ assert_eq!(is_cwd_relative(&path), cwd);
+ assert_eq!(path.is_relative(), rel);
}
)
}
let dest = Path::new($dest);
let exp = $exp;
let res = path.is_ancestor_of(&dest);
- assert!(res == exp,
- "`{}`.is_ancestor_of(`{}`): Expected {}, found {}",
- path.as_str().unwrap(), dest.as_str().unwrap(), exp, res);
+ assert_eq!(res, exp);
}
)
}
macro_rules! t {
(s: $path:expr, $other:expr, $exp:expr) => (
{
- let path = Path::new($path);
- let other = Path::new($other);
- let res = path.path_relative_from(&other);
- let exp = $exp;
- assert!(res.as_ref().and_then(|x| x.as_str()) == exp,
- "`{}`.path_relative_from(`{}`): Expected {}, got {}",
- path.as_str().unwrap(), other.as_str().unwrap(), exp,
- res.as_ref().and_then(|x| x.as_str()));
+ assert_eq!(Path::new($path).path_relative_from(&Path::new($other))
+ .as_ref().and_then(|x| x.as_str()), $exp);
}
)
}
let path = Path::new($path);
let exp: Option<&str> = $exp;
let exp = exp.map(|s| Path::new(s));
- assert!(make_non_verbatim(&path) == exp);
+ assert_eq!(make_non_verbatim(&path), exp);
}
)
}
#![stable]
// Reexported core operators
-#[stable] #[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Sync};
+#[stable] #[doc(no_inline)] pub use marker::{Copy, Send, Sized, Sync};
#[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
+// TEMPORARY
+#[unstable] #[doc(no_inline)] pub use ops::{Index, IndexMut, FullRange};
+
// Reexported functions
#[stable] #[doc(no_inline)] pub use mem::drop;
//! use std::rand;
//!
//! let tuple = rand::random::<(f64, char)>();
-//! println!("{}", tuple)
+//! println!("{:?}", tuple)
//! ```
//!
//! ## Monte Carlo estimation of π
pub fn weak_rng() -> XorShiftRng {
match OsRng::new() {
Ok(mut r) => r.gen(),
- Err(e) => panic!("weak_rng: failed to create seeded RNG: {}", e)
+ Err(e) => panic!("weak_rng: failed to create seeded RNG: {:?}", e)
}
}
let mut r = thread_rng();
let a = r.gen::<f64>();
let b = r.gen::<f64>();
- debug!("{}", (a, b));
+ debug!("{:?}", (a, b));
}
#[test]
use mem;
use os::errno;
- // NOTE: for old macros; remove after the next snapshot
- #[cfg(stage0)] use result::Result::Err;
-
#[cfg(all(target_os = "linux",
any(target_arch = "x86_64",
target_arch = "x86",
extern crate libc;
use io::{IoResult};
- use kinds::Sync;
+ use marker::Sync;
use mem;
use os;
use rand::Rng;
r.fill_bytes(&mut v);
Thread::yield_now();
}
- }).detach();
+ });
}
// start all the tasks
if v.len() == 0 { return }
match self.reader.read_at_least(v.len(), v) {
Ok(_) => {}
- Err(e) => panic!("ReaderRng.fill_bytes error: {}", e)
+ Err(e) => panic!("ReaderRng.fill_bytes error: {:?}", e)
}
}
}
//! they aren't defined anywhere outside of the `rt` module.
macro_rules! rterrln {
- ($fmt:expr $($arg:tt)*) => ( {
- ::rt::util::dumb_print(format_args!(concat!($fmt, "\n") $($arg)*))
+ ($fmt:expr) => ( {
+ ::rt::util::dumb_print(format_args!(concat!($fmt, "\n")))
+ } );
+ ($fmt:expr, $($arg:expr),*) => ( {
+ ::rt::util::dumb_print(format_args!(concat!($fmt, "\n"), $($arg)*))
} )
}
// Some basic logging. Enabled by passing `--cfg rtdebug` to the libstd build.
macro_rules! rtdebug {
- ($($arg:tt)*) => ( {
+ ($arg:expr) => ( {
if cfg!(rtdebug) {
- rterrln!($($arg)*)
+ rterrln!($arg)
+ }
+ } );
+ ($str:expr, $($arg:expr),*) => ( {
+ if cfg!(rtdebug) {
+ rterrln!($str, $($arg)*)
}
})
}
#![allow(dead_code)]
-use kinds::Send;
+use marker::Send;
use ops::FnOnce;
use sys;
use thunk::Thunk;
pub mod backtrace;
// Internals
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
mod macros;
// These should be refactored/moved/made private over time
// MAX_CALLBACKS, so we're sure to clamp it as necessary.
let callbacks = {
let amt = CALLBACK_CNT.load(Ordering::SeqCst);
- CALLBACKS[..cmp::min(amt, MAX_CALLBACKS)]
+ CALLBACKS.index(&(0..cmp::min(amt, MAX_CALLBACKS)))
};
for cb in callbacks.iter() {
match cb.load(Ordering::SeqCst) {
impl<'a> fmt::Writer for BufWriter<'a> {
fn write_str(&mut self, bytes: &str) -> fmt::Result {
let left = self.buf.slice_from_mut(self.pos);
- let to_write = bytes.as_bytes()[..cmp::min(bytes.len(), left.len())];
+ let to_write = bytes.as_bytes().index(&(0..cmp::min(bytes.len(), left.len())));
slice::bytes::copy_memory(left, to_write);
self.pos += to_write.len();
Ok(())
let mut msg = [0u8; 512];
let mut w = BufWriter { buf: &mut msg, pos: 0 };
let _ = write!(&mut w, "{}", args);
- let msg = str::from_utf8(w.buf[mut ..w.pos]).unwrap_or("aborted");
+ let msg = str::from_utf8(w.buf.index_mut(&(0..w.pos))).unwrap_or("aborted");
let msg = if msg.is_empty() {"aborted"} else {msg};
// Give some context to the message
/// println!("before wait");
/// c.wait();
/// println!("after wait");
-/// }).detach();
+/// });
/// }
/// ```
#[stable]
let tx = tx.clone();
Thread::spawn(move|| {
tx.send(c.wait().is_leader()).unwrap();
- }).detach();
+ });
}
// At this point, all spawned tasks should be blocked,
/// let mut started = lock.lock().unwrap();
/// *started = true;
/// cvar.notify_one();
-/// }).detach();
+/// });
///
/// // wait for the thread to start up
/// let &(ref lock, ref cvar) = &*pair;
cnt = cond.wait(cnt).unwrap();
}
tx.send(()).unwrap();
- }).detach();
+ });
}
drop(tx);
Thread::spawn(move |:| {
// Don't panic if the other end has hung up
let _ = tx.send(blk());
- }).detach();
+ });
Future::from_receiver(rx)
}
use thread::Thread;
use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
use sync::Arc;
-use kinds::{Sync, Send};
-use kinds::marker::{NoSend, NoSync};
+use marker::{Sync, Send};
+use marker::{NoSend, NoSync};
use mem;
use clone::Clone;
//! let (tx, rx) = channel();
//! Thread::spawn(move|| {
//! tx.send(10i).unwrap();
-//! }).detach();
+//! });
//! assert_eq!(rx.recv().unwrap(), 10i);
//! ```
//!
//! let tx = tx.clone();
//! Thread::spawn(move|| {
//! tx.send(i).unwrap();
-//! }).detach()
+//! });
//! }
//!
//! for _ in range(0i, 10i) {
//! Thread::spawn(move|| {
//! // This will wait for the parent task to start receiving
//! tx.send(53).unwrap();
-//! }).detach();
+//! });
//! rx.recv().unwrap();
//! ```
//!
use sync::Arc;
use fmt;
-use kinds::marker;
+use marker;
use mem;
use cell::UnsafeCell;
/// Thread::spawn(move|| {
/// # fn expensive_computation() {}
/// tx.send(expensive_computation()).unwrap();
-/// }).detach();
+/// });
///
/// // Do some useful work for awhile
///
/// // Let's see what that answer was
-/// println!("{}", rx.recv().unwrap());
+/// println!("{:?}", rx.recv().unwrap());
/// ```
#[stable]
pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) {
/// Thread::spawn(move|| {
/// // this will block until the previous message has been received
/// tx.send(2i).unwrap();
-/// }).detach();
+/// });
///
/// assert_eq!(rx.recv().unwrap(), 1i);
/// assert_eq!(rx.recv().unwrap(), 2i);
#[test]
fn stress() {
let (tx, rx) = channel::<int>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
for _ in range(0u, 10000) { tx.send(1i).unwrap(); }
});
for _ in range(0u, 10000) {
static NTHREADS: uint = 8;
let (tx, rx) = channel::<int>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
for _ in range(0, AMT * NTHREADS) {
assert_eq!(rx.recv().unwrap(), 1);
}
let tx = tx.clone();
Thread::spawn(move|| {
for _ in range(0, AMT) { tx.send(1).unwrap(); }
- }).detach();
+ });
}
drop(tx);
t.join().ok().unwrap();
fn send_from_outside_runtime() {
let (tx1, rx1) = channel::<()>();
let (tx2, rx2) = channel::<int>();
- let t1 = Thread::spawn(move|| {
+ let t1 = Thread::scoped(move|| {
tx1.send(()).unwrap();
for _ in range(0i, 40) {
assert_eq!(rx2.recv().unwrap(), 1);
}
});
rx1.recv().unwrap();
- let t2 = Thread::spawn(move|| {
+ let t2 = Thread::scoped(move|| {
for _ in range(0i, 40) {
tx2.send(1).unwrap();
}
#[test]
fn recv_from_outside_runtime() {
let (tx, rx) = channel::<int>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
for _ in range(0i, 40) {
assert_eq!(rx.recv().unwrap(), 1);
}
fn no_runtime() {
let (tx1, rx1) = channel::<int>();
let (tx2, rx2) = channel::<int>();
- let t1 = Thread::spawn(move|| {
+ let t1 = Thread::scoped(move|| {
assert_eq!(rx1.recv().unwrap(), 1);
tx2.send(2).unwrap();
});
- let t2 = Thread::spawn(move|| {
+ let t2 = Thread::scoped(move|| {
tx1.send(1).unwrap();
assert_eq!(rx2.recv().unwrap(), 2);
});
#[test]
fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will panic
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
let (tx, rx) = channel::<int>();
drop(tx);
rx.recv().unwrap();
let _t = Thread::spawn(move|| {
drop(tx);
});
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
assert!(rx.recv().unwrap() == box 10);
}).join();
assert!(res.is_err());
let _t = Thread::spawn(move|| {
drop(rx);
});
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
tx.send(1).unwrap();
}).join();
}
for _ in range(0, stress_factor()) {
let (tx, rx) = channel::<int>();
Thread::spawn(move|| {
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
rx.recv().unwrap();
}).join();
assert!(res.is_err());
- }).detach();
+ });
let _t = Thread::spawn(move|| {
Thread::spawn(move|| {
drop(tx);
- }).detach();
+ });
});
}
}
Thread::spawn(move|| {
tx.send(box i).unwrap();
send(tx, i + 1);
- }).detach();
+ });
}
fn recv(rx: Receiver<Box<int>>, i: int) {
Thread::spawn(move|| {
assert!(rx.recv().unwrap() == box i);
recv(rx, i + 1);
- }).detach();
+ });
}
}
}
let tx = tx.clone();
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
+ });
}
for _ in range(0, total) {
Thread::spawn(move|| {
tx.send(1).unwrap();
tx.send(1).unwrap();
- }).detach();
+ });
while rx.recv().is_ok() {}
}
let (tx, rx) = sync_channel::<int>(0);
Thread::spawn(move|| {
for _ in range(0u, 10000) { tx.send(1).unwrap(); }
- }).detach();
+ });
for _ in range(0u, 10000) {
assert_eq!(rx.recv().unwrap(), 1);
}
_ => {}
}
dtx.send(()).unwrap();
- }).detach();
+ });
for _ in range(0, NTHREADS) {
let tx = tx.clone();
Thread::spawn(move|| {
for _ in range(0, AMT) { tx.send(1).unwrap(); }
- }).detach();
+ });
}
drop(tx);
drx.recv().unwrap();
#[test]
fn oneshot_single_thread_recv_chan_close() {
// Receiving on a closed chan will panic
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
let (tx, rx) = sync_channel::<int>(0);
drop(tx);
rx.recv().unwrap();
let _t = Thread::spawn(move|| {
drop(tx);
});
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
assert!(rx.recv().unwrap() == box 10);
}).join();
assert!(res.is_err());
let _t = Thread::spawn(move|| {
drop(rx);
});
- let _ = Thread::spawn(move || {
+ let _ = Thread::scoped(move || {
tx.send(1).unwrap();
}).join();
}
for _ in range(0, stress_factor()) {
let (tx, rx) = sync_channel::<int>(0);
let _t = Thread::spawn(move|| {
- let res = Thread::spawn(move|| {
+ let res = Thread::scoped(move|| {
rx.recv().unwrap();
}).join();
assert!(res.is_err());
let _t = Thread::spawn(move|| {
Thread::spawn(move|| {
drop(tx);
- }).detach();
+ });
});
}
}
Thread::spawn(move|| {
tx.send(box i).unwrap();
send(tx, i + 1);
- }).detach();
+ });
}
fn recv(rx: Receiver<Box<int>>, i: int) {
Thread::spawn(move|| {
assert!(rx.recv().unwrap() == box i);
recv(rx, i + 1);
- }).detach();
+ });
}
}
}
let tx = tx.clone();
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
+ });
}
for _ in range(0, total) {
q.push(i);
}
tx.send(()).unwrap();
- }).detach();
+ });
}
let mut i = 0u;
use core::prelude::*;
use core::cell::Cell;
-use core::kinds::marker;
+use core::marker;
use core::mem;
use core::uint;
let start = self.start;
self.size -= 1;
self.start = (self.start + 1) % self.buf.len();
- self.buf[start].take().unwrap()
+ let result = &mut self.buf[start];
+ result.take().unwrap()
}
fn size(&self) -> uint { self.size }
use prelude::v1::*;
use cell::UnsafeCell;
-use kinds::marker;
+use marker;
use ops::{Deref, DerefMut};
use sync::poison::{self, TryLockError, TryLockResult, LockResult};
use sys_common::mutex as sys;
/// tx.send(()).unwrap();
/// }
/// // the lock is unlocked here when `data` goes out of scope.
-/// }).detach();
+/// });
/// }
///
/// rx.recv().unwrap();
/// let lock = Arc::new(Mutex::new(0u));
/// let lock2 = lock.clone();
///
-/// let _ = Thread::spawn(move || -> () {
+/// let _ = Thread::scoped(move || -> () {
/// // This thread will acquire the mutex first, unwrapping the result of
/// // `lock` because the lock has not been poisoned.
/// let _lock = lock2.lock().unwrap();
let (tx, rx) = channel();
for _ in range(0, K) {
let tx2 = tx.clone();
- Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }).detach();
+ Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
let tx2 = tx.clone();
- Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); }).detach();
+ Thread::spawn(move|| { inc(); tx2.send(()).unwrap(); });
}
drop(tx);
fn test_mutex_arc_poison() {
let arc = Arc::new(Mutex::new(1i));
let arc2 = arc.clone();
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
let lock = arc2.lock().unwrap();
assert_eq!(*lock, 2);
}).join();
fn test_mutex_arc_access_in_unwind() {
let arc = Arc::new(Mutex::new(1i));
let arc2 = arc.clone();
- let _ = Thread::spawn(move|| -> () {
+ let _ = Thread::scoped(move|| -> () {
struct Unwinder {
i: Arc<Mutex<int>>,
}
//! example use case would be for initializing an FFI library.
use int;
-use kinds::Sync;
+use marker::Sync;
use mem::drop;
use ops::FnOnce;
use sync::atomic::{AtomicInt, Ordering, ATOMIC_INT_INIT};
assert!(run);
}
tx.send(()).unwrap();
- }).detach();
+ });
}
unsafe {
use prelude::v1::*;
use cell::UnsafeCell;
-use kinds::marker;
+use marker;
use ops::{Deref, DerefMut};
use sync::poison::{self, LockResult, TryLockError, TryLockResult};
use sys_common::rwlock as sys;
}
}
drop(tx);
- }).detach();
+ });
}
drop(tx);
let _ = rx.recv();
fn test_rw_arc_poison_wr() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.write().unwrap();
panic!();
}).join();
fn test_rw_arc_poison_ww() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.write().unwrap();
panic!();
}).join();
fn test_rw_arc_no_poison_rr() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.read().unwrap();
panic!();
}).join();
fn test_rw_arc_no_poison_rw() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _: Result<uint, _> = Thread::spawn(move|| {
+ let _: Result<uint, _> = Thread::scoped(move|| {
let _lock = arc2.read().unwrap();
panic!()
}).join();
*lock = tmp + 1;
}
tx.send(()).unwrap();
- }).detach();
+ });
// Readers try to catch the writer in the act
let mut children = Vec::new();
for _ in range(0u, 5) {
let arc3 = arc.clone();
- children.push(Thread::spawn(move|| {
+ children.push(Thread::scoped(move|| {
let lock = arc3.read().unwrap();
assert!(*lock >= 0);
}));
fn test_rw_arc_access_in_unwind() {
let arc = Arc::new(RwLock::new(1i));
let arc2 = arc.clone();
- let _ = Thread::spawn(move|| -> () {
+ let _ = Thread::scoped(move|| -> () {
struct Unwinder {
i: Arc<RwLock<int>>,
}
tx.send(()).unwrap();
drop(s2.access());
tx.send(()).unwrap();
- }).detach();
+ });
rx.recv().unwrap(); // wait for child to come alive
}
rx.recv().unwrap(); // wait for child to be done
}
sentinel.cancel();
- }).detach();
+ });
}
#[cfg(test)]
while rest.len() > 0 {
if rest.starts_with("$") {
macro_rules! demangle {
- ($($pat:expr => $demangled:expr),*) => ({
+ ($($pat:expr, => $demangled:expr),*) => ({
$(if rest.starts_with($pat) {
try!(writer.write_str($demangled));
rest = rest.slice_from($pat.len());
// see src/librustc/back/link.rs for these mappings
demangle! (
- "$SP$" => "@",
- "$UP$" => "Box",
- "$RP$" => "*",
- "$BP$" => "&",
- "$LT$" => "<",
- "$GT$" => ">",
- "$LP$" => "(",
- "$RP$" => ")",
- "$C$" => ",",
+ "$SP$", => "@",
+ "$UP$", => "Box",
+ "$RP$", => "*",
+ "$BP$", => "&",
+ "$LT$", => "<",
+ "$GT$", => ">",
+ "$LP$", => "(",
+ "$RP$", => ")",
+ "$C$", => ",",
// in theory we can demangle any Unicode code point, but
// for simplicity we just catch the common ones.
- "$u{20}" => " ",
- "$u{27}" => "'",
- "$u{5b}" => "[",
- "$u{5d}" => "]"
+ "$u{20}", => " ",
+ "$u{27}", => "'",
+ "$u{5b}", => "[",
+ "$u{5d}", => "]"
)
} else {
let idx = match rest.find('$') {
let _g = self.lock.lock().unwrap();
*self.shutdown.get() = true;
self.cond.notify_one()
- }).detach();
+ });
rt::at_exit(move|:| { self.shutdown() });
*self.initialized.get() = true;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use kinds::Sync;
+use marker::Sync;
use sys::mutex as imp;
/// An OS-based mutual exclusion lock.
// Also as with read(), we use MSG_DONTWAIT to guard ourselves
// against unforeseen circumstances.
let _guard = lock();
- let ptr = buf[written..].as_ptr();
+ let ptr = buf.index(&(written..)).as_ptr();
let len = buf.len() - written;
match retry(|| write(deadline.is_some(), ptr, len)) {
-1 if wouldblock() => {}
// Finally, after all that work above, we can emit a symbol.
fn output(w: &mut Writer, idx: int, addr: *mut libc::c_void,
s: Option<&[u8]>) -> IoResult<()> {
- try!(write!(w, " {:2}: {:2$} - ", idx, addr, HEX_WIDTH));
+ try!(write!(w, " {:2}: {:2$?} - ", idx, addr, HEX_WIDTH));
match s.and_then(|s| str::from_utf8(s).ok()) {
Some(string) => try!(demangle(w, string)),
None => try!(write!(w, "<unknown>")),
sa_restorer: *mut libc::c_void,
}
- unsafe impl ::kinds::Send for sigaction { }
- unsafe impl ::kinds::Sync for sigaction { }
+ unsafe impl ::marker::Send for sigaction { }
+ unsafe impl ::marker::Sync for sigaction { }
#[repr(C)]
#[cfg(target_word_size = "32")]
sa_resv: [libc::c_int; 1],
}
- unsafe impl ::kinds::Send for sigaction { }
- unsafe impl ::kinds::Sync for sigaction { }
+ unsafe impl ::marker::Send for sigaction { }
+ unsafe impl ::marker::Sync for sigaction { }
#[repr(C)]
pub struct sigset_t {
assert_eq!(buf[2], 's' as u8);
assert_eq!(buf[3], 't' as u8);
}
- r => panic!("invalid read: {}", r),
+ r => panic!("invalid read: {:?}", r),
}
assert!(writer.read(&mut buf).is_err());
// except according to those terms.
use cell::UnsafeCell;
-use kinds::Sync;
+use marker::Sync;
use sys::sync as ffi;
use sys_common::mutex;
return match input.read(&mut bytes) {
Ok(8) => {
assert!(combine(CLOEXEC_MSG_FOOTER) == combine(bytes.slice(4, 8)),
- "Validation on the CLOEXEC pipe failed: {}", bytes);
+ "Validation on the CLOEXEC pipe failed: {:?}", bytes);
let errno = combine(bytes.slice(0, 4));
assert!(p.wait(0).is_ok(), "wait(0) should either return Ok or panic");
Err(super::decode_error(errno))
Err(ref e) if e.kind == EndOfFile => Ok(p),
Err(e) => {
assert!(p.wait(0).is_ok(), "wait(0) should either return Ok or panic");
- panic!("the CLOEXEC pipe failed: {}", e)
+ panic!("the CLOEXEC pipe failed: {:?}", e)
},
Ok(..) => { // pipe I/O up to PIPE_BUF bytes should be atomic
assert!(p.wait(0).is_ok(), "wait(0) should either return Ok or panic");
let mut status = 0 as c_int;
if deadline == 0 {
return match retry(|| unsafe { c::waitpid(self.pid, &mut status, 0) }) {
- -1 => panic!("unknown waitpid error: {}", super::last_error()),
+ -1 => panic!("unknown waitpid error: {:?}", super::last_error()),
_ => Ok(translate_status(status)),
}
}
continue
}
- n => panic!("error in select {} ({})", os::errno(), n),
+ n => panic!("error in select {:?} ({:?})", os::errno(), n),
}
// Process any pending messages
n if n > 0 => { ret = true; }
0 => return true,
-1 if wouldblock() => return ret,
- n => panic!("bad read {} ({})", os::last_os_error(), n),
+ n => panic!("bad read {:?} ({:?})", os::last_os_error(), n),
}
}
}
} {
1 => {}
-1 if wouldblock() => {} // see above comments
- n => panic!("bad error on write fd: {} {}", n, os::errno()),
+ n => panic!("bad error on write fd: {:?} {:?}", n, os::errno()),
}
}
}
}) {
n if n == self.pid => Some(translate_status(status)),
0 => None,
- n => panic!("unknown waitpid error `{}`: {}", n,
+ n => panic!("unknown waitpid error `{:?}`: {:?}", n,
super::last_error()),
}
}
debug_assert_eq!(r, 0);
}
-#[cfg(target_os = "macos")]
+#[cfg(any(target_os = "macos",
+ target_os = "ios"))]
type pthread_key_t = ::libc::c_ulong;
-#[cfg(not(target_os = "macos"))]
+#[cfg(any(target_os = "freebsd",
+ target_os = "dragonfly"))]
+type pthread_key_t = ::libc::c_int;
+
+#[cfg(not(any(target_os = "macos",
+ target_os = "ios",
+ target_os = "freebsd",
+ target_os = "dragonfly")))]
type pthread_key_t = ::libc::c_uint;
extern {
use dynamic_lib::DynamicLibrary;
use ffi;
+use core::ops::Index;
use intrinsics;
use io::{IoResult, Writer};
use libc;
let bytes = unsafe { ffi::c_str_to_bytes(&ptr) };
match str::from_utf8(bytes) {
Ok(s) => try!(demangle(w, s)),
- Err(..) => try!(w.write(bytes[..bytes.len()-1])),
+ Err(..) => try!(w.write(bytes.index(&(..(bytes.len()-1))))),
}
}
try!(w.write(&['\n' as u8]));
set.fd_count += 1;
}
+pub type SHORT = libc::c_short;
+
+#[repr(C)]
+pub struct COORD {
+ pub X: SHORT,
+ pub Y: SHORT,
+}
+
+#[repr(C)]
+pub struct SMALL_RECT {
+ pub Left: SHORT,
+ pub Top: SHORT,
+ pub Right: SHORT,
+ pub Bottom: SHORT,
+}
+
+#[repr(C)]
+pub struct CONSOLE_SCREEN_BUFFER_INFO {
+ pub dwSize: COORD,
+ pub dwCursorPosition: COORD,
+ pub wAttributes: libc::WORD,
+ pub srWindow: SMALL_RECT,
+ pub dwMaximumWindowSize: COORD,
+}
+pub type PCONSOLE_SCREEN_BUFFER_INFO = *mut CONSOLE_SCREEN_BUFFER_INFO;
+
#[link(name = "ws2_32")]
extern "system" {
pub fn WSAStartup(wVersionRequested: libc::WORD,
/// they are used to be passed to the real function if available.
macro_rules! compat_fn {
($module:ident::$symbol:ident($($argname:ident: $argtype:ty),*)
- -> $rettype:ty $fallback:block) => (
+ -> $rettype:ty { $fallback:expr }) => (
#[inline(always)]
pub unsafe fn $symbol($($argname: $argtype),*) -> $rettype {
static mut ptr: extern "system" fn($($argname: $argtype),*) -> $rettype = thunk;
}
}
- extern "system" fn fallback($($argname: $argtype),*) -> $rettype $fallback
+ extern "system" fn fallback($($argname: $argtype),*)
+ -> $rettype { $fallback }
::intrinsics::atomic_load_relaxed(&ptr)($($argname),*)
}
- );
-
- ($module:ident::$symbol:ident($($argname:ident: $argtype:ty),*) $fallback:block) => (
- compat_fn!($module::$symbol($($argname: $argtype),*) -> () $fallback)
)
}
fn SetLastError(dwErrCode: DWORD);
}
- compat_fn! { kernel32::CreateSymbolicLinkW(_lpSymlinkFileName: LPCWSTR,
- _lpTargetFileName: LPCWSTR,
- _dwFlags: DWORD) -> BOOLEAN {
- unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); }
- 0
- } }
-
- compat_fn! { kernel32::GetFinalPathNameByHandleW(_hFile: HANDLE,
- _lpszFilePath: LPCWSTR,
- _cchFilePath: DWORD,
- _dwFlags: DWORD) -> DWORD {
- unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); }
- 0
- } }
+ compat_fn! {
+ kernel32::CreateSymbolicLinkW(_lpSymlinkFileName: LPCWSTR,
+ _lpTargetFileName: LPCWSTR,
+ _dwFlags: DWORD) -> BOOLEAN {
+ unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0 }
+ }
+ }
+
+ compat_fn! {
+ kernel32::GetFinalPathNameByHandleW(_hFile: HANDLE,
+ _lpszFilePath: LPCWSTR,
+ _cchFilePath: DWORD,
+ _dwFlags: DWORD) -> DWORD {
+ unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0 }
+ }
+ }
}
}
pub fn SetConsoleMode(hConsoleHandle: libc::HANDLE,
lpMode: libc::DWORD) -> libc::BOOL;
+ pub fn GetConsoleScreenBufferInfo(
+ hConsoleOutput: libc::HANDLE,
+ lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO,
+ ) -> libc::BOOL;
}
pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] {
match v.iter().position(|c| *c == 0) {
// don't include the 0
- Some(i) => v[..i],
+ Some(i) => v.index(&(0..i)),
None => v
}
}
}
let ret = unsafe {
libc::WriteFile(self.handle(),
- buf[offset..].as_ptr() as libc::LPVOID,
+ buf.index(&(offset..)).as_ptr() as libc::LPVOID,
(buf.len() - offset) as libc::DWORD,
&mut bytes_written,
&mut overlapped)
use ptr;
use str;
use sys::fs::FileDesc;
+use sync::{StaticMutex, MUTEX_INIT};
+
use sys::fs;
use sys::{self, retry, c, wouldblock, set_nonblocking, ms_to_timeval, timer};
use sys_common::helper_thread::Helper;
pub use sys_common::ProcessConfig;
+// `CreateProcess` is racy!
+// http://support.microsoft.com/kb/315939
+static CREATE_PROCESS_LOCK: StaticMutex = MUTEX_INIT;
+
/// A value representing a child process.
///
/// The lifetime of this value is linked to the lifetime of the actual
with_dirp(cfg.cwd(), |dirp| {
let mut cmd_str: Vec<u16> = cmd_str.utf16_units().collect();
cmd_str.push(0);
+ let _lock = CREATE_PROCESS_LOCK.lock().unwrap();
let created = CreateProcessW(ptr::null(),
cmd_str.as_mut_ptr(),
ptr::null_mut(),
if ret as uint == 0 {
// be sure to not leak the closure
let _p: Box<Thunk> = mem::transmute(arg);
- panic!("failed to spawn native thread: {}", ret);
+ panic!("failed to spawn native thread: {:?}", ret);
}
return ret;
}
use libc::types::os::arch::extra::LPCVOID;
use libc::{c_int, HANDLE, LPDWORD, DWORD, LPVOID};
use libc::{get_osfhandle, CloseHandle};
+use mem;
use ptr;
use str::from_utf8;
use super::c::{ENABLE_ECHO_INPUT, ENABLE_EXTENDED_FLAGS};
use super::c::{ENABLE_INSERT_MODE, ENABLE_LINE_INPUT};
use super::c::{ENABLE_PROCESSED_INPUT, ENABLE_QUICK_EDIT_MODE};
-use super::c::{ERROR_ILLEGAL_CHARACTER};
+use super::c::{ERROR_ILLEGAL_CHARACTER, CONSOLE_SCREEN_BUFFER_INFO};
use super::c::{ReadConsoleW, WriteConsoleW, GetConsoleMode, SetConsoleMode};
+use super::c::{GetConsoleScreenBufferInfo};
fn invalid_encoding() -> IoError {
IoError {
}
pub fn get_winsize(&mut self) -> IoResult<(int, int)> {
- // FIXME
- // Get console buffer via CreateFile with CONOUT$
- // Make a CONSOLE_SCREEN_BUFFER_INFO
- // Call GetConsoleScreenBufferInfo
- // Maybe call GetLargestConsoleWindowSize instead?
- Err(super::unimpl())
+ let mut info: CONSOLE_SCREEN_BUFFER_INFO = unsafe { mem::zeroed() };
+ match unsafe { GetConsoleScreenBufferInfo(self.handle, &mut info as *mut _) } {
+ 0 => Err(super::last_error()),
+ _ => Ok(((info.srWindow.Right + 1 - info.srWindow.Left) as int,
+ (info.srWindow.Bottom + 1 - info.srWindow.Top) as int)),
+ }
}
// Let us magically declare this as a TTY
//! each with their own stack and local state.
//!
//! Communication between threads can be done through
-//! [channels](../../std/comm/index.html), Rust's message-passing
+//! [channels](../../std/sync/mpsc/index.html), Rust's message-passing
//! types, along with [other forms of thread
//! synchronization](../../std/sync/index.html) and shared-memory data
//! structures. In particular, types that are guaranteed to be
//! ```rust
//! use std::thread::Thread;
//!
-//! let guard = Thread::spawn(move || {
+//! let thread = Thread::spawn(move || {
//! println!("Hello, World!");
//! // some computation here
//! });
-//! let result = guard.join();
//! ```
//!
-//! The `spawn` function doesn't return a `Thread` directly; instead, it returns
-//! a *join guard* from which a `Thread` can be extracted. The join guard is an
-//! RAII-style guard that will automatically join the child thread (block until
-//! it terminates) when it is dropped. You can join the child thread in advance
-//! by calling the `join` method on the guard, which will also return the result
-//! produced by the thread.
+//! The spawned thread is "detached" from the current thread, meaning that it
+//! can outlive the thread that spawned it. (Note, however, that when the main
+//! thread terminates all detached threads are terminated as well.) The returned
+//! `Thread` handle can be used for low-level synchronization as described below.
+//!
+//! ## Scoped threads
//!
-//! If you instead wish to *detach* the child thread, allowing it to outlive its
-//! parent, you can use the `detach` method on the guard,
+//! Often a parent thread uses a child thread to perform some particular task,
+//! and at some point must wait for the child to complete before continuing.
+//! For this scenario, use the `scoped` constructor:
//!
-//! A handle to the thread itself is available via the `thread` method on the
-//! join guard.
+//! ```rust
+//! use std::thread::Thread;
+//!
+//! let guard = Thread::scoped(move || {
+//! println!("Hello, World!");
+//! // some computation here
+//! });
+//! // do some other work in the meantime
+//! let result = guard.join();
+//! ```
+//!
+//! The `scoped` function doesn't return a `Thread` directly; instead, it
+//! returns a *join guard* from which a `Thread` can be extracted. The join
+//! guard is an RAII-style guard that will automatically join the child thread
+//! (block until it terminates) when it is dropped. You can join the child
+//! thread in advance by calling the `join` method on the guard, which will also
+//! return the result produced by the thread. A handle to the thread itself is
+//! available via the `thread` method on the join guard.
+//!
+//! (Note: eventually, the `scoped` constructor will allow the parent and child
+//! threads to data that lives on the parent thread's stack, but some language
+//! changes are needed before this is possible.)
//!
//! ## Configuring threads
//!
//!
//! thread::Builder::new().name("child1".to_string()).spawn(move || {
//! println!("Hello, world!")
-//! }).detach();
+//! });
//! ```
//!
//! ## Blocking support: park and unpark
//!
//! * It can be implemented highly efficiently on many platforms.
+#![stable]
+
use any::Any;
use boxed::Box;
use cell::UnsafeCell;
use clone::Clone;
-use kinds::{Send, Sync};
+use marker::{Send, Sync};
use ops::{Drop, FnOnce};
use option::Option::{self, Some, None};
use result::Result::{Err, Ok};
/// Thread configuration. Provides detailed control over the properties
/// and behavior of new threads.
+#[stable]
pub struct Builder {
// A name for the thread-to-be, for identification in panic messages
name: Option<String>,
impl Builder {
/// Generate the base configuration for spawning a thread, from which
/// configuration methods can be chained.
+ #[stable]
pub fn new() -> Builder {
Builder {
name: None,
/// Name the thread-to-be. Currently the name is used for identification
/// only in panic messages.
+ #[stable]
pub fn name(mut self, name: String) -> Builder {
self.name = Some(name);
self
}
/// Set the size of the stack for the new thread.
+ #[stable]
pub fn stack_size(mut self, size: uint) -> Builder {
self.stack_size = Some(size);
self
self
}
- /// Spawn a new joinable thread, and return a JoinGuard guard for it.
+ /// Spawn a new detached thread, and return a handle to it.
///
/// See `Thead::spawn` and the module doc for more details.
- pub fn spawn<T, F>(self, f: F) -> JoinGuard<T> where
- T: Send, F: FnOnce() -> T, F: Send
- {
- self.spawn_inner(Thunk::new(f))
+ #[unstable = "may change with specifics of new Send semantics"]
+ pub fn spawn<F>(self, f: F) -> Thread where F: FnOnce(), F: Send + 'static {
+ let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(|_| {}));
+ unsafe { imp::detach(native) };
+ thread
}
- fn spawn_inner<T: Send>(self, f: Thunk<(), T>) -> JoinGuard<T> {
+ /// Spawn a new child thread that must be joined within a given
+ /// scope, and return a `JoinGuard`.
+ ///
+ /// See `Thead::scoped` and the module doc for more details.
+ #[unstable = "may change with specifics of new Send semantics"]
+ pub fn scoped<'a, T, F>(self, f: F) -> JoinGuard<'a, T> where
+ T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
+ {
let my_packet = Packet(Arc::new(UnsafeCell::new(None)));
let their_packet = Packet(my_packet.0.clone());
+ let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(move |: ret| unsafe {
+ *their_packet.0.get() = Some(ret);
+ }));
+ JoinGuard {
+ native: native,
+ joined: false,
+ packet: my_packet,
+ thread: thread,
+ }
+ }
+
+ fn spawn_inner<T: Send>(self, f: Thunk<(), T>, finish: Thunk<Result<T>, ()>)
+ -> (imp::rust_thread, Thread)
+ {
let Builder { name, stack_size, stdout, stderr } = self;
let stack_size = stack_size.unwrap_or(rt::min_stack());
unwind::try(move || *ptr = Some(f.invoke(())))
}
};
- unsafe {
- *their_packet.0.get() = Some(match (output, try_result) {
- (Some(data), Ok(_)) => Ok(data),
- (None, Err(cause)) => Err(cause),
- _ => unreachable!()
- });
- }
+ finish.invoke(match (output, try_result) {
+ (Some(data), Ok(_)) => Ok(data),
+ (None, Err(cause)) => Err(cause),
+ _ => unreachable!()
+ });
};
- JoinGuard {
- native: unsafe { imp::create(stack_size, Thunk::new(main)) },
- joined: false,
- packet: my_packet,
- thread: my_thread,
- }
+ (unsafe { imp::create(stack_size, Thunk::new(main)) }, my_thread)
}
}
unsafe impl Sync for Inner {}
#[derive(Clone)]
+#[stable]
/// A handle to a thread.
pub struct Thread {
inner: Arc<Inner>,
}
-unsafe impl Sync for Thread {}
-
impl Thread {
// Used only internally to construct a thread object without spawning
fn new(name: Option<String>) -> Thread {
}
}
- /// Spawn a new joinable thread, returning a `JoinGuard` for it.
+ /// Spawn a new detached thread, returning a handle to it.
+ ///
+ /// The child thread may outlive the parent (unless the parent thread is the
+ /// main thread; the whole process is terminated when the main thread
+ /// finishes.) The thread handle can be used for low-level
+ /// synchronization. See the module documentation for additional details.
+ #[unstable = "may change with specifics of new Send semantics"]
+ pub fn spawn<F>(f: F) -> Thread where F: FnOnce(), F: Send + 'static {
+ Builder::new().spawn(f)
+ }
+
+ /// Spawn a new *scoped* thread, returning a `JoinGuard` for it.
///
/// The join guard can be used to explicitly join the child thread (via
/// `join`), returning `Result<T>`, or it will implicitly join the child
- /// upon being dropped. To detach the child, allowing it to outlive the
- /// current thread, use `detach`. See the module documentation for additional details.
- pub fn spawn<T, F>(f: F) -> JoinGuard<T> where
- T: Send, F: FnOnce() -> T, F: Send
+ /// upon being dropped. Because the child thread may refer to data on the
+ /// current thread's stack (hence the "scoped" name), it cannot be detached;
+ /// it *must* be joined before the relevant stack frame is popped. See the
+ /// module documentation for additional details.
+ #[unstable = "may change with specifics of new Send semantics"]
+ pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where
+ T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
{
- Builder::new().spawn(f)
+ Builder::new().scoped(f)
}
/// Gets a handle to the thread that invokes it.
+ #[stable]
pub fn current() -> Thread {
thread_info::current_thread()
}
/// Cooperatively give up a timeslice to the OS scheduler.
+ #[unstable = "name may change"]
pub fn yield_now() {
unsafe { imp::yield_now() }
}
/// Determines whether the current thread is panicking.
#[inline]
+ #[stable]
pub fn panicking() -> bool {
unwind::panicking()
}
// future, this will be implemented in a more efficient way, perhaps along the lines of
// http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp
// or futuxes, and in either case may allow spurious wakeups.
+ #[unstable = "recently introduced"]
pub fn park() {
let thread = Thread::current();
let mut guard = thread.inner.lock.lock().unwrap();
/// Atomically makes the handle's token available if it is not already.
///
/// See the module doc for more detail.
+ #[unstable = "recently introduced"]
pub fn unpark(&self) {
let mut guard = self.inner.lock.lock().unwrap();
if !*guard {
}
/// Get the thread's name.
+ #[stable]
pub fn name(&self) -> Option<&str> {
self.inner.name.as_ref().map(|s| s.as_slice())
}
/// Indicates the manner in which a thread exited.
///
/// A thread that completes without panicking is considered to exit successfully.
+#[stable]
pub type Result<T> = ::result::Result<T, Box<Any + Send>>;
struct Packet<T>(Arc<UnsafeCell<Option<Result<T>>>>);
unsafe impl<T:'static+Send> Send for Packet<T> {}
unsafe impl<T> Sync for Packet<T> {}
-#[must_use]
/// An RAII-style guard that will block until thread termination when dropped.
///
/// The type `T` is the return type for the thread's main function.
-pub struct JoinGuard<T> {
+#[must_use]
+#[unstable = "may change with specifics of new Send semantics"]
+pub struct JoinGuard<'a, T: 'a> {
native: imp::rust_thread,
thread: Thread,
joined: bool,
packet: Packet<T>,
}
-unsafe impl<T: Send> Sync for JoinGuard<T> {}
+#[stable]
+unsafe impl<'a, T: Send + 'a> Sync for JoinGuard<'a, T> {}
-impl<T: Send> JoinGuard<T> {
+impl<'a, T: Send + 'a> JoinGuard<'a, T> {
/// Extract a handle to the thread this guard will join on.
+ #[stable]
pub fn thread(&self) -> &Thread {
&self.thread
}
///
/// If the child thread panics, `Err` is returned with the parameter given
/// to `panic`.
+ #[stable]
pub fn join(mut self) -> Result<T> {
assert!(!self.joined);
unsafe { imp::join(self.native) };
(*self.packet.0.get()).take().unwrap()
}
}
+}
+impl<T: Send> JoinGuard<'static, T> {
/// Detaches the child thread, allowing it to outlive its parent.
+ #[experimental = "unsure whether this API imposes limitations elsewhere"]
pub fn detach(mut self) {
unsafe { imp::detach(self.native) };
self.joined = true; // avoid joining in the destructor
#[unsafe_destructor]
#[stable]
-impl<T: Send> Drop for JoinGuard<T> {
+impl<'a, T: Send + 'a> Drop for JoinGuard<'a, T> {
fn drop(&mut self) {
if !self.joined {
unsafe { imp::join(self.native) };
#[test]
fn test_unnamed_thread() {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
assert!(Thread::current().name().is_none());
}).join().map_err(|_| ()).unwrap();
}
#[test]
fn test_named_thread() {
- Builder::new().name("ada lovelace".to_string()).spawn(move|| {
+ Builder::new().name("ada lovelace".to_string()).scoped(move|| {
assert!(Thread::current().name().unwrap() == "ada lovelace".to_string());
}).join().map_err(|_| ()).unwrap();
}
let (tx, rx) = channel();
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
+ });
rx.recv().unwrap();
}
#[test]
fn test_join_success() {
- match Thread::spawn(move|| -> String {
+ match Thread::scoped(move|| -> String {
"Success!".to_string()
}).join().as_ref().map(|s| s.as_slice()) {
result::Result::Ok("Success!") => (),
#[test]
fn test_join_panic() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!()
}).join() {
result::Result::Err(_) => (),
} else {
f(i - 1, tx);
}
- }).detach();
+ });
}
f(10, tx);
Thread::spawn(move|| {
Thread::spawn(move|| {
tx.send(()).unwrap();
- }).detach();
- }).detach();
+ });
+ });
rx.recv().unwrap();
}
#[test]
fn test_avoid_copying_the_body_spawn() {
avoid_copying_the_body(|v| {
- Thread::spawn(move || v.invoke(())).detach();
+ Thread::spawn(move || v.invoke(()));
});
}
avoid_copying_the_body(|f| {
Thread::spawn(move|| {
f.invoke(());
- }).detach();
+ });
})
}
#[test]
fn test_avoid_copying_the_body_join() {
avoid_copying_the_body(|f| {
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
f.invoke(())
}).join();
})
fn child_no(x: uint) -> Thunk {
return Thunk::new(move|| {
if x < GENERATIONS {
- Thread::spawn(move|| child_no(x+1).invoke(())).detach();
+ Thread::spawn(move|| child_no(x+1).invoke(()));
}
});
}
- Thread::spawn(|| child_no(0).invoke(())).detach();
+ Thread::spawn(|| child_no(0).invoke(()));
}
#[test]
fn test_simple_newsched_spawn() {
- Thread::spawn(move || {}).detach();
+ Thread::spawn(move || {});
}
#[test]
fn test_try_panic_message_static_str() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!("static string");
}).join() {
Err(e) => {
#[test]
fn test_try_panic_message_owned_str() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!("owned string".to_string());
}).join() {
Err(e) => {
#[test]
fn test_try_panic_message_any() {
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!(box 413u16 as Box<Any + Send>);
}).join() {
Err(e) => {
fn test_try_panic_message_unit_struct() {
struct Juju;
- match Thread::spawn(move|| {
+ match Thread::scoped(move|| {
panic!(Juju)
}).join() {
Err(ref e) if e.is::<Juju>() => {}
let mut reader = ChanReader::new(rx);
let stdout = ChanWriter::new(tx);
- let r = Builder::new().stdout(box stdout as Box<Writer + Send>).spawn(move|| {
+ let r = Builder::new().stdout(box stdout as Box<Writer + Send>).scoped(move|| {
print!("Hello, world!");
}).join();
assert!(r.is_ok());
use cell::UnsafeCell;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod scoped;
// Sure wish we had macro hygiene, no?
/// assert_eq!(*f.borrow(), 1);
/// *f.borrow_mut() = 3;
/// });
-/// }).detach();
+/// });
///
/// // we retain our original value of 2 despite the child thread
/// FOO.with(|f| {
pub dtor_running: UnsafeCell<bool>, // should be Cell
}
- unsafe impl<T> ::kinds::Sync for Key<T> { }
+ unsafe impl<T> ::marker::Sync for Key<T> { }
#[doc(hidden)]
impl<T> Key<T> {
pub os: OsStaticKey,
}
- unsafe impl<T> ::kinds::Sync for Key<T> { }
+ unsafe impl<T> ::marker::Sync for Key<T> { }
struct Value<T: 'static> {
key: &'static Key<T>,
}
thread_local!(static FOO: Foo = foo());
- Thread::spawn(|| {
+ Thread::scoped(|| {
assert!(FOO.state() == State::Uninitialized);
FOO.with(|_| {
assert!(FOO.state() == State::Valid);
}
}
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
drop(S1);
}).join().ok().unwrap();
}
}
}
- Thread::spawn(move|| unsafe {
+ Thread::scoped(move|| unsafe {
K1.with(|s| *s.get() = Some(S1));
}).join().ok().unwrap();
}
const _INIT: __Key<$t> = __Key {
inner: ::std::thread_local::scoped::__impl::KeyInner {
inner: ::std::thread_local::scoped::__impl::OS_INIT,
- marker: ::std::kinds::marker::InvariantType,
+ marker: ::std::marker::InvariantType,
}
};
#[doc(hidden)]
pub struct KeyInner<T> { pub inner: UnsafeCell<*mut T> }
- unsafe impl<T> ::kinds::Sync for KeyInner<T> { }
+ unsafe impl<T> ::marker::Sync for KeyInner<T> { }
#[doc(hidden)]
impl<T> KeyInner<T> {
#[cfg(any(windows, target_os = "android", target_os = "ios", target_arch = "aarch64"))]
mod imp {
- use kinds::marker;
+ use marker;
use sys_common::thread_local::StaticKey as OsStaticKey;
#[doc(hidden)]
pub marker: marker::InvariantType<T>,
}
- unsafe impl<T> ::kinds::Sync for KeyInner<T> { }
+ unsafe impl<T> ::marker::Sync for KeyInner<T> { }
#[doc(hidden)]
impl<T> KeyInner<T> {
#![allow(missing_docs)]
use alloc::boxed::Box;
-use core::kinds::Send;
+use core::marker::Send;
use core::ops::FnOnce;
pub struct Thunk<A=(),R=()> {
use num::Int;
use result::Result::Ok;
-// NOTE: for old macros; remove after the next snapshot
-#[cfg(stage0)] use result::Result::Err;
-
/// The number of nanoseconds in a microsecond.
const NANOS_PER_MICRO: i32 = 1000;
/// The number of nanoseconds in a millisecond.
/// ISO 8601 time duration with nanosecond precision.
/// This also allows for the negative duration; see individual methods for details.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Show)]
pub struct Duration {
secs: i64,
nanos: i32, // Always 0 <= nanos < NANOS_PER_SEC
}
}
-impl fmt::Show for Duration {
+impl fmt::String for Duration {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// technically speaking, negative duration is not valid ISO 8601,
// but we need to print it anyway.
}
#[allow(non_camel_case_types)]
-#[derive(Copy, PartialEq)]
+#[derive(Copy, PartialEq, Show)]
pub enum Architecture {
X86,
X86_64,
}
impl fmt::Show for Abi {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for Abi {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "\"{}\"", self.name())
}
}
impl fmt::Show for Os {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for Os {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
OsLinux => "linux".fmt(f),
}
}
-impl Show for Ident {
+//NOTE(stage0): remove after snapshot
+impl fmt::Show for Ident {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}#{}", self.name, self.ctxt)
}
}
-impl Show for Name {
+impl fmt::String for Ident {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(&self.name, f)
+ }
+}
+
+impl fmt::Show for Name {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let Name(nm) = *self;
- write!(f, "\"{}\"({})", token::get_name(*self).get(), nm)
+ write!(f, "{:?}({})", token::get_name(*self).get(), nm)
+ }
+}
+
+impl fmt::String for Name {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(token::get_name(*self).get(), f)
}
}
/// A mark represents a unique id associated with a macro expansion
pub type Mrk = u32;
-#[cfg(stage0)]
-impl<S: Encoder<E>, E> Encodable<S, E> for Ident {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_str(token::get_ident(*self).get())
- }
-}
-
-#[cfg(not(stage0))]
impl Encodable for Ident {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_str(token::get_ident(*self).get())
}
}
-#[cfg(stage0)]
-impl<D: Decoder<E>, E> Decodable<D, E> for Ident {
- fn decode(d: &mut D) -> Result<Ident, E> {
- Ok(str_to_ident(try!(d.read_str())[]))
- }
-}
-
-#[cfg(not(stage0))]
impl Decodable for Ident {
fn decode<D: Decoder>(d: &mut D) -> Result<Ident, D::Error> {
- Ok(str_to_ident(try!(d.read_str())[]))
+ Ok(str_to_ident(try!(d.read_str()).index(&FullRange)))
}
}
pub fn len(&self) -> uint {
match *self {
TtToken(_, token::DocComment(_)) => 2,
- TtToken(_, token::SubstNt(..)) => 2,
TtToken(_, token::SpecialVarNt(..)) => 2,
TtToken(_, token::MatchNt(..)) => 3,
TtDelimited(_, ref delimed) => {
}
delimed.tts[index - 1].clone()
}
- (&TtToken(sp, token::SubstNt(name, name_st)), _) => {
- let v = [TtToken(sp, token::Dollar),
- TtToken(sp, token::Ident(name, name_st))];
- v[index]
- }
(&TtToken(sp, token::SpecialVarNt(var)), _) => {
let v = [TtToken(sp, token::Dollar),
TtToken(sp, token::Ident(token::str_to_ident(var.as_str()),
Plus
}
-impl<T> Sign where T: Int {
- pub fn new(n: T) -> Sign {
+impl Sign {
+ pub fn new<T:Int>(n: T) -> Sign {
if n < Int::zero() {
Minus
} else {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
pub enum IntTy {
- TyI,
+ TyIs,
TyI8,
TyI16,
TyI32,
TyI64,
}
+//NOTE(stage0): remove after snapshot
impl fmt::Show for IntTy {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for IntTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", ast_util::int_ty_to_string(*self, None))
}
impl IntTy {
pub fn suffix_len(&self) -> uint {
match *self {
- TyI => 1,
+ TyIs => 1,
TyI8 => 2,
TyI16 | TyI32 | TyI64 => 3,
}
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
pub enum UintTy {
- TyU,
+ TyUs,
TyU8,
TyU16,
TyU32,
impl UintTy {
pub fn suffix_len(&self) -> uint {
match *self {
- TyU => 1,
+ TyUs => 1,
TyU8 => 2,
TyU16 | TyU32 | TyU64 => 3,
}
}
}
+//NOTE(stage0): remove after snapshot
impl fmt::Show for UintTy {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for UintTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", ast_util::uint_ty_to_string(*self, None))
}
TyF64,
}
+//NOTE(stage0): remove after snapshot
impl fmt::Show for FloatTy {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for FloatTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", ast_util::float_ty_to_string(*self))
}
impl fmt::Show for Onceness {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match *self {
- Once => "once".fmt(f),
- Many => "many".fmt(f),
- }
+ fmt::String::fmt(match *self {
+ Once => "once",
+ Many => "many",
+ }, f)
+ }
+}
+
+impl fmt::String for Onceness {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(match *self {
+ Once => "once",
+ Many => "many",
+ }, f)
}
}
pub variadic: bool
}
-#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)]
+#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Show)]
pub enum Unsafety {
Unsafe,
Normal,
}
-impl fmt::Show for Unsafety {
+impl fmt::String for Unsafety {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match *self {
- Unsafety::Normal => "normal".fmt(f),
- Unsafety::Unsafe => "unsafe".fmt(f),
- }
+ fmt::String::fmt(match *self {
+ Unsafety::Normal => "normal",
+ Unsafety::Unsafe => "unsafe",
+ }, f)
}
}
}
}
+//NOTE(stage0): replace with deriving(Show) after snapshot
impl fmt::Show for PathElem {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for PathElem {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let slot = token::get_name(self.name());
write!(f, "{}", slot)
if !s.is_empty() {
s.push_str("::");
}
- s.push_str(e[]);
+ s.push_str(e.index(&FullRange));
s
}).to_string()
}
PathName(ident.name)
}
MethMac(_) => {
- panic!("no path elem for {}", node)
+ panic!("no path elem for {:?}", node)
}
}
}
MethDecl(ident, _, _, _, _, _, _, _) => {
PathName(ident.name)
}
- MethMac(_) => panic!("no path elem for {}", node),
+ MethMac(_) => panic!("no path elem for {:?}", node),
}
}
TypeTraitItem(ref m) => {
}
},
NodeVariant(v) => PathName(v.node.name.name),
- _ => panic!("no path elem for {}", node)
+ _ => panic!("no path elem for {:?}", node)
}
}
F: FnOnce(Option<&[Attribute]>) -> T,
{
let attrs = match self.get(id) {
- NodeItem(i) => Some(i.attrs[]),
- NodeForeignItem(fi) => Some(fi.attrs[]),
+ NodeItem(i) => Some(i.attrs.index(&FullRange)),
+ NodeForeignItem(fi) => Some(fi.attrs.index(&FullRange)),
NodeTraitItem(ref tm) => match **tm {
- RequiredMethod(ref type_m) => Some(type_m.attrs[]),
- ProvidedMethod(ref m) => Some(m.attrs[]),
- TypeTraitItem(ref typ) => Some(typ.attrs[]),
+ RequiredMethod(ref type_m) => Some(type_m.attrs.index(&FullRange)),
+ ProvidedMethod(ref m) => Some(m.attrs.index(&FullRange)),
+ TypeTraitItem(ref typ) => Some(typ.attrs.index(&FullRange)),
},
NodeImplItem(ref ii) => {
match **ii {
- MethodImplItem(ref m) => Some(m.attrs[]),
- TypeImplItem(ref t) => Some(t.attrs[]),
+ MethodImplItem(ref m) => Some(m.attrs.index(&FullRange)),
+ TypeImplItem(ref t) => Some(t.attrs.index(&FullRange)),
}
}
- NodeVariant(ref v) => Some(v.node.attrs[]),
+ NodeVariant(ref v) => Some(v.node.attrs.index(&FullRange)),
// unit/tuple structs take the attributes straight from
// the struct definition.
// FIXME(eddyb) make this work again (requires access to the map).
NodesMatchingSuffix {
map: self,
item_name: parts.last().unwrap(),
- in_which: parts[..parts.len() - 1],
+ in_which: parts.index(&(0..(parts.len() - 1))),
idx: 0,
}
}
pub fn span(&self, id: NodeId) -> Span {
self.opt_span(id)
- .unwrap_or_else(|| panic!("AstMap.span: could not find span for id {}", id))
+ .unwrap_or_else(|| panic!("AstMap.span: could not find span for id {:?}", id))
}
pub fn def_id_span(&self, def_id: DefId, fallback: Span) -> Span {
None => return false,
Some((node_id, name)) => (node_id, name),
};
- if part[] != mod_name.as_str() {
+ if part.index(&FullRange) != mod_name.as_str() {
return false;
}
cursor = self.map.get_parent(mod_id);
// We are looking at some node `n` with a given name and parent
// id; do their names match what I am seeking?
fn matches_names(&self, parent_of_n: NodeId, name: Name) -> bool {
- name.as_str() == self.item_name[] &&
+ name.as_str() == self.item_name.index(&FullRange) &&
self.suffix_matches(parent_of_n)
}
}
impl<'ast> NodeCollector<'ast> {
fn insert_entry(&mut self, id: NodeId, entry: MapEntry<'ast>) {
- debug!("ast_map: {} => {}", id, entry);
+ debug!("ast_map: {:?} => {:?}", id, entry);
let len = self.map.len();
if id as uint >= len {
self.map.extend(repeat(NotPresent).take(id as uint - len + 1));
fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String {
let id_str = format!(" (id={})", id);
- let id_str = if include_id { id_str[] } else { "" };
+ let id_str = if include_id { id_str.index(&FullRange) } else { "" };
match map.find(id) {
Some(NodeItem(item)) => {
/// We want to avoid "45int" and "-3int" in favor of "45" and "-3"
pub fn int_ty_to_string(t: IntTy, val: Option<i64>) -> String {
let s = match t {
- TyI if val.is_some() => "i",
- TyI => "int",
+ TyIs if val.is_some() => "is",
+ TyIs => "isize",
TyI8 => "i8",
TyI16 => "i16",
TyI32 => "i32",
match t {
TyI8 => 0x80u64,
TyI16 => 0x8000u64,
- TyI | TyI32 => 0x80000000u64, // actually ni about TyI
+ TyIs | TyI32 => 0x80000000u64, // actually ni about TyIs
TyI64 => 0x8000000000000000u64
}
}
/// We want to avoid "42uint" in favor of "42u"
pub fn uint_ty_to_string(t: UintTy, val: Option<u64>) -> String {
let s = match t {
- TyU if val.is_some() => "u",
- TyU => "uint",
+ TyUs if val.is_some() => "us",
+ TyUs => "usize",
TyU8 => "u8",
TyU16 => "u16",
TyU32 => "u32",
match t {
TyU8 => 0xffu64,
TyU16 => 0xffffu64,
- TyU | TyU32 => 0xffffffffu64, // actually ni about TyU
+ TyUs | TyU32 => 0xffffffffu64, // actually ni about TyUs
TyU64 => 0xffffffffffffffffu64
}
}
match *trait_ref {
Some(ref trait_ref) => {
pretty.push('.');
- pretty.push_str(pprust::path_to_string(&trait_ref.path)[]);
+ pretty.push_str(pprust::path_to_string(&trait_ref.path).index(&FullRange));
}
None => {}
}
- token::gensym_ident(pretty[])
+ token::gensym_ident(pretty.index(&FullRange))
}
pub fn trait_method_to_ty_method(method: &Method) -> TypeMethod {
pub fn path_name_eq(a : &ast::Path, b : &ast::Path) -> bool {
(a.span == b.span)
&& (a.global == b.global)
- && (segments_name_eq(a.segments[], b.segments[]))
+ && (segments_name_eq(a.segments.index(&FullRange), b.segments.index(&FullRange)))
}
// are two arrays of segments equal when compared unhygienically?
#[test] fn idents_name_eq_test() {
assert!(segments_name_eq(
[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
- .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[],
+ .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange),
[Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}]
- .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[]));
+ .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange)));
assert!(!segments_name_eq(
[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
- .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[],
+ .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange),
[Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}]
- .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[]));
+ .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange)));
}
}
use std::cell::{RefCell, Cell};
use std::collections::BitvSet;
use std::collections::HashSet;
+use std::fmt;
thread_local! { static USED_ATTRS: RefCell<BitvSet> = RefCell::new(BitvSet::new()) }
fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
match self.node {
- MetaList(_, ref l) => Some(l[]),
+ MetaList(_, ref l) => Some(l.index(&FullRange)),
_ => None
}
}
let meta = mk_name_value_item_str(
InternedString::new("doc"),
token::intern_and_get_ident(strip_doc_comment_decoration(
- comment.get())[]));
+ comment.get()).index(&FullRange)));
if self.node.style == ast::AttrOuter {
f(&mk_attr_outer(self.node.id, meta))
} else {
}
MetaList(ref n, ref items) if *n == "inline" => {
mark_used(attr);
- if contains_name(items[], "always") {
+ if contains_name(items.index(&FullRange), "always") {
InlineAlways
- } else if contains_name(items[], "never") {
+ } else if contains_name(items.index(&FullRange), "never") {
InlineNever
} else {
InlineHint
!cfg_matches(diagnostic, cfgs, &*mis[0])
}
ast::MetaList(ref pred, _) => {
- diagnostic.span_err(cfg.span, format!("invalid predicate `{}`", pred)[]);
+ diagnostic.span_err(cfg.span, format!("invalid predicate `{}`", pred).as_slice());
false
},
ast::MetaWord(_) | ast::MetaNameValue(..) => contains(cfgs, cfg),
Locked
}
+impl fmt::String for StabilityLevel {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ fmt::Show::fmt(self, f)
+ }
+}
+
pub fn find_stability_generic<'a,
AM: AttrMetaMethods,
I: Iterator<Item=&'a AM>>
if !set.insert(name.clone()) {
diagnostic.span_fatal(meta.span,
- format!("duplicate meta item `{}`", name)[]);
+ format!("duplicate meta item `{}`", name).index(&FullRange));
}
}
}
"u32" => Some(UnsignedInt(ast::TyU32)),
"i64" => Some(SignedInt(ast::TyI64)),
"u64" => Some(UnsignedInt(ast::TyU64)),
- "int" => Some(SignedInt(ast::TyI)),
- "uint" => Some(UnsignedInt(ast::TyU)),
+ "int" => Some(SignedInt(ast::TyIs)),
+ "uint" => Some(UnsignedInt(ast::TyUs)),
+ "isize" => Some(SignedInt(ast::TyIs)),
+ "usize" => Some(UnsignedInt(ast::TyUs)),
_ => None
}
}
SignedInt(ast::TyI16) | UnsignedInt(ast::TyU16) |
SignedInt(ast::TyI32) | UnsignedInt(ast::TyU32) |
SignedInt(ast::TyI64) | UnsignedInt(ast::TyU64) => true,
- SignedInt(ast::TyI) | UnsignedInt(ast::TyU) => false
+ SignedInt(ast::TyIs) | UnsignedInt(ast::TyUs) => false
}
}
}
impl Eq for Span {}
-#[cfg(stage0)]
-impl<S:Encoder<E>, E> Encodable<S, E> for Span {
- /* Note #1972 -- spans are encoded but not decoded */
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_nil()
- }
-}
-
-#[cfg(not(stage0))]
impl Encodable for Span {
/* Note #1972 -- spans are encoded but not decoded */
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
}
}
-#[cfg(stage0)]
-impl<D:Decoder<E>, E> Decodable<D, E> for Span {
- fn decode(_d: &mut D) -> Result<Span, E> {
- Ok(DUMMY_SP)
- }
-}
-
-#[cfg(not(stage0))]
impl Decodable for Span {
fn decode<D: Decoder>(_d: &mut D) -> Result<Span, D::Error> {
Ok(DUMMY_SP)
lines.get(line_number).map(|&line| {
let begin: BytePos = line - self.start_pos;
let begin = begin.to_uint();
- let slice = self.src[begin..];
+ let slice = self.src.index(&(begin..));
match slice.find('\n') {
- Some(e) => slice[0..e],
+ Some(e) => slice.index(&(0..e)),
None => slice
}.to_string()
})
// FIXME #12884: no efficient/safe way to remove from the start of a string
// and reuse the allocation.
let mut src = if src.starts_with("\u{feff}") {
- String::from_str(src[3..])
+ String::from_str(src.index(&(3..)))
} else {
- String::from_str(src[])
+ String::from_str(src.index(&FullRange))
};
// Append '\n' in case it's not already there.
if begin.fm.start_pos != end.fm.start_pos {
None
} else {
- Some(begin.fm.src[begin.pos.to_uint()..
- end.pos.to_uint()].to_string())
+ Some(begin.fm.src.index(&(begin.pos.to_uint()..
+ end.pos.to_uint())).to_string())
}
}
let mut total_extra_bytes = 0;
for mbc in map.multibyte_chars.borrow().iter() {
- debug!("{}-byte char at {}", mbc.bytes, mbc.pos);
+ debug!("{}-byte char at {:?}", mbc.bytes, mbc.pos);
if mbc.pos < bpos {
// every character is at least one byte, so we only
// count the actual extra bytes.
let chpos = self.bytepos_to_file_charpos(pos);
let linebpos = (*f.lines.borrow())[a];
let linechpos = self.bytepos_to_file_charpos(linebpos);
- debug!("byte pos {} is on the line at byte pos {}",
+ debug!("byte pos {:?} is on the line at byte pos {:?}",
pos, linebpos);
- debug!("char pos {} is on the line at char pos {}",
+ debug!("char pos {:?} is on the line at char pos {:?}",
chpos, linechpos);
debug!("byte is on line: {}", line);
assert!(chpos >= linechpos);
panic!(ExplicitBug);
}
pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
- self.span_bug(sp, format!("unimplemented {}", msg)[]);
+ self.span_bug(sp, format!("unimplemented {}", msg).index(&FullRange));
}
pub fn handler<'a>(&'a self) -> &'a Handler {
&self.handler
self.err_count.get());
}
}
- self.fatal(s[]);
+ self.fatal(s.index(&FullRange));
}
pub fn warn(&self, msg: &str) {
self.emit.borrow_mut().emit(None, msg, None, Warning);
panic!(ExplicitBug);
}
pub fn unimpl(&self, msg: &str) -> ! {
- self.bug(format!("unimplemented {}", msg)[]);
+ self.bug(format!("unimplemented {}", msg).index(&FullRange));
}
pub fn emit(&self,
cmsp: Option<(&codemap::CodeMap, Span)>,
}
}
-#[derive(Copy, PartialEq, Clone)]
+#[derive(Copy, PartialEq, Clone, Show)]
pub enum Level {
Bug,
Fatal,
Help,
}
-impl fmt::Show for Level {
+impl fmt::String for Level {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- use std::fmt::Show;
+ use std::fmt::String;
match *self {
Bug => "error: internal compiler error".fmt(f),
// to be miscolored. We assume this is rare enough that we don't
// have to worry about it.
if msg.ends_with("\n") {
- try!(t.write_str(msg[0..msg.len()-1]));
+ try!(t.write_str(msg.index(&(0..(msg.len()-1)))));
try!(t.reset());
try!(t.write_str("\n"));
} else {
}
try!(print_maybe_styled(dst,
- format!("{}: ", lvl.to_string())[],
+ format!("{}: ", lvl.to_string()).index(&FullRange),
term::attr::ForegroundColor(lvl.color())));
try!(print_maybe_styled(dst,
- format!("{}", msg)[],
+ format!("{}", msg).index(&FullRange),
term::attr::Bold));
match code {
Some(code) => {
let style = term::attr::ForegroundColor(term::color::BRIGHT_MAGENTA);
- try!(print_maybe_styled(dst, format!(" [{}]", code.clone())[], style));
+ try!(print_maybe_styled(dst, format!(" [{}]", code.clone()).index(&FullRange), style));
}
None => ()
}
match error {
Ok(()) => {}
- Err(e) => panic!("failed to print diagnostics: {}", e),
+ Err(e) => panic!("failed to print diagnostics: {:?}", e),
}
}
sp: RenderSpan, msg: &str, lvl: Level) {
match emit(self, cm, sp, msg, None, lvl, true) {
Ok(()) => {}
- Err(e) => panic!("failed to print diagnostics: {}", e),
+ Err(e) => panic!("failed to print diagnostics: {:?}", e),
}
}
}
// the span)
let span_end = Span { lo: sp.hi, hi: sp.hi, expn_id: sp.expn_id};
let ses = cm.span_to_string(span_end);
- try!(print_diagnostic(dst, ses[], lvl, msg, code));
+ try!(print_diagnostic(dst, ses.index(&FullRange), lvl, msg, code));
if rsp.is_full_span() {
try!(custom_highlight_lines(dst, cm, sp, lvl, lines));
}
} else {
- try!(print_diagnostic(dst, ss[], lvl, msg, code));
+ try!(print_diagnostic(dst, ss.index(&FullRange), lvl, msg, code));
if rsp.is_full_span() {
try!(highlight_lines(dst, cm, sp, lvl, lines));
}
Some(code) =>
match dst.registry.as_ref().and_then(|registry| registry.find_description(code)) {
Some(_) => {
- try!(print_diagnostic(dst, ss[], Help,
+ try!(print_diagnostic(dst, ss.index(&FullRange), Help,
format!("pass `--explain {}` to see a detailed \
- explanation", code)[], None));
+ explanation", code).index(&FullRange), None));
}
None => ()
},
let fm = &*lines.file;
let mut elided = false;
- let mut display_lines = lines.lines[];
+ let mut display_lines = lines.lines.index(&FullRange);
if display_lines.len() > MAX_LINES {
- display_lines = display_lines[0u..MAX_LINES];
+ display_lines = display_lines.index(&(0u..MAX_LINES));
elided = true;
}
// Print the offending lines
}
}
try!(print_maybe_styled(err,
- format!("{}\n", s)[],
+ format!("{}\n", s).index(&FullRange),
term::attr::ForegroundColor(lvl.color())));
}
Ok(())
-> io::IoResult<()> {
let fm = &*lines.file;
- let lines = lines.lines[];
+ let lines = lines.lines.index(&FullRange);
if lines.len() > MAX_LINES {
if let Some(line) = fm.get_line(lines[0]) {
try!(write!(&mut w.dst, "{}:{} {}\n", fm.name,
s.push('^');
s.push('\n');
print_maybe_styled(w,
- s[],
+ s.index(&FullRange),
term::attr::ForegroundColor(lvl.color()))
}
codemap::MacroAttribute => ("#[", "]"),
codemap::MacroBang => ("", "!")
};
- try!(print_diagnostic(w, ss[], Note,
+ try!(print_diagnostic(w, ss.index(&FullRange), Note,
format!("in expansion of {}{}{}", pre,
ei.callee.name,
- post)[], None));
+ post).index(&FullRange), None));
let ss = cm.span_to_string(ei.call_site);
- try!(print_diagnostic(w, ss[], Note, "expansion site", None));
+ try!(print_diagnostic(w, ss.index(&FullRange), Note, "expansion site", None));
Ok(Some(ei.call_site))
}
None => Ok(None)
{
match opt {
Some(t) => t,
- None => diag.handler().bug(msg()[]),
+ None => diag.handler().bug(msg().index(&FullRange)),
}
}
Some(previous_span) => {
ecx.span_warn(span, format!(
"diagnostic code {} already used", token::get_ident(code).get()
- )[]);
+ ).index(&FullRange));
ecx.span_note(previous_span, "previous invocation");
},
None => ()
if diagnostics.insert(code.name, description).is_some() {
ecx.span_err(span, format!(
"diagnostic code {} already registered", token::get_ident(*code).get()
- )[]);
+ ).index(&FullRange));
}
});
let sym = Ident::new(token::gensym((
"__register_diagnostic_".to_string() + token::get_ident(*code).get()
- )[]));
+ ).index(&FullRange)));
MacItems::new(vec![quote_item!(ecx, mod $sym {}).unwrap()].into_iter())
}
Some(('=', _)) => None,
Some(('+', operand)) => {
Some(token::intern_and_get_ident(format!(
- "={}", operand)[]))
+ "={}", operand).index(&FullRange)))
}
_ => {
cx.span_err(span, "output operand constraint lacks '=' or '+'");
pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); }
pub fn mod_path(&self) -> Vec<ast::Ident> {
let mut v = Vec::new();
- v.push(token::str_to_ident(self.ecfg.crate_name[]));
+ v.push(token::str_to_ident(self.ecfg.crate_name.index(&FullRange)));
v.extend(self.mod_path.iter().map(|a| *a));
return v;
}
if self.recursion_count > self.ecfg.recursion_limit {
self.span_fatal(ei.call_site,
format!("recursion limit reached while expanding the macro `{}`",
- ei.callee.name)[]);
+ ei.callee.name).index(&FullRange));
}
let mut call_site = ei.call_site;
tts: &[ast::TokenTree],
name: &str) {
if tts.len() != 0 {
- cx.span_err(sp, format!("{} takes no arguments", name)[]);
+ cx.span_err(sp, format!("{} takes no arguments", name).index(&FullRange));
}
}
-> Option<String> {
let mut p = cx.new_parser_from_tts(tts);
if p.token == token::Eof {
- cx.span_err(sp, format!("{} takes 1 argument", name)[]);
+ cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange));
return None
}
let ret = cx.expander().fold_expr(p.parse_expr());
if p.token != token::Eof {
- cx.span_err(sp, format!("{} takes 1 argument", name)[]);
+ cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange));
}
expr_to_string(cx, ret, "argument must be a string literal").map(|(s, _)| {
s.get().to_string()
self.expr(sp, ast::ExprLit(P(respan(sp, lit))))
}
fn expr_uint(&self, span: Span, i: uint) -> P<ast::Expr> {
- self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyU)))
+ self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs)))
}
fn expr_int(&self, sp: Span, i: int) -> P<ast::Expr> {
- self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyI, ast::Sign::new(i))))
+ self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs, ast::Sign::new(i))))
}
fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr> {
self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8)))
let loc = self.codemap().lookup_char_pos(span.lo);
let expr_file = self.expr_str(span,
token::intern_and_get_ident(loc.file
- .name[]));
+ .name.index(&FullRange)));
let expr_line = self.expr_uint(span, loc.line);
let expr_file_line_tuple = self.expr_tuple(span, vec!(expr_file, expr_line));
let expr_file_line_ptr = self.expr_addr_of(span, expr_file_line_tuple);
ast::LitInt(i, ast::UnsignedIntLit(_)) |
ast::LitInt(i, ast::SignedIntLit(_, ast::Plus)) |
ast::LitInt(i, ast::UnsuffixedIntLit(ast::Plus)) => {
- accumulator.push_str(format!("{}", i)[]);
+ accumulator.push_str(format!("{}", i).index(&FullRange));
}
ast::LitInt(i, ast::SignedIntLit(_, ast::Minus)) |
ast::LitInt(i, ast::UnsuffixedIntLit(ast::Minus)) => {
- accumulator.push_str(format!("-{}", i)[]);
+ accumulator.push_str(format!("-{}", i).index(&FullRange));
}
ast::LitBool(b) => {
- accumulator.push_str(format!("{}", b)[]);
+ accumulator.push_str(format!("{}", b).index(&FullRange));
}
ast::LitByte(..) |
ast::LitBinary(..) => {
}
base::MacExpr::new(cx.expr_str(
sp,
- token::intern_and_get_ident(accumulator[])))
+ token::intern_and_get_ident(accumulator.index(&FullRange))))
}
}
}
}
- let res = str_to_ident(res_str[]);
+ let res = str_to_ident(res_str.index(&FullRange));
let e = P(ast::Expr {
id: ast::DUMMY_NODE_ID,
"Send" | "Sync" => {
return cx.span_err(span,
format!("{} is an unsafe trait and it \
- should be implemented explicitly", *tname)[])
+ should be implemented explicitly",
+ *tname).as_slice())
}
ref tname => {
cx.span_bug(span,
format!("expected built-in trait name but \
- found {}", *tname)[])
+ found {}", *tname).as_slice())
}
}
},
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
- path: Path::new(vec!("std", "kinds", name)),
+ path: Path::new(vec!("std", "marker", name)),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!()
EnumNonMatchingCollapsed (..) => {
cx.span_bug(trait_span,
format!("non-matching enum variants in \
- `deriving({})`", name)[])
+ `deriving({})`", name).index(&FullRange))
}
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span,
- format!("static method in `deriving({})`", name)[])
+ format!("static method in `deriving({})`", name).index(&FullRange))
}
}
None => {
cx.span_bug(trait_span,
format!("unnamed field in normal struct in \
- `deriving({})`", name)[])
+ `deriving({})`", name).index(&FullRange))
}
};
cx.field_imm(field.span, ident, subcall(field))
let fields = fields.iter().enumerate().map(|(i, &span)| {
getarg(cx, span,
token::intern_and_get_ident(format!("_field{}",
- i)[]),
+ i).index(&FullRange)),
i)
}).collect();
let name = match name {
Some(id) => token::get_ident(id),
None => {
- token::intern_and_get_ident(format!("_field{}", i)[])
+ token::intern_and_get_ident(format!("_field{}", i).index(&FullRange))
}
};
let enc = cx.expr_method_call(span, self_.clone(),
self,
struct_def,
type_ident,
- self_args[],
- nonself_args[])
+ self_args.index(&FullRange),
+ nonself_args.index(&FullRange))
} else {
method_def.expand_struct_method_body(cx,
self,
struct_def,
type_ident,
- self_args[],
- nonself_args[])
+ self_args.index(&FullRange),
+ nonself_args.index(&FullRange))
};
method_def.create_method(cx,
self,
enum_def,
type_ident,
- self_args[],
- nonself_args[])
+ self_args.index(&FullRange),
+ nonself_args.index(&FullRange))
} else {
method_def.expand_enum_method_body(cx,
self,
enum_def,
type_ident,
self_args,
- nonself_args[])
+ nonself_args.index(&FullRange))
};
method_def.create_method(cx,
};
let mut f = self.combine_substructure.borrow_mut();
let f: &mut CombineSubstructureFunc = &mut *f;
- f.call_mut((cx, trait_.span, &substructure))
+ f(cx, trait_.span, &substructure)
}
fn get_ret_ty(&self,
for (i, ty) in self.args.iter().enumerate() {
let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics);
- let ident = cx.ident_of(format!("__arg_{}", i)[]);
+ let ident = cx.ident_of(format!("__arg_{}", i).index(&FullRange));
arg_tys.push((ident, ast_ty));
let arg_expr = cx.expr_ident(trait_.span, ident);
struct_path,
struct_def,
format!("__self_{}",
- i)[],
+ i).index(&FullRange),
ast::MutImmutable);
patterns.push(pat);
raw_fields.push(ident_expr);
.collect::<Vec<String>>();
let self_arg_idents = self_arg_names.iter()
- .map(|name|cx.ident_of(name[]))
+ .map(|name|cx.ident_of(name.index(&FullRange)))
.collect::<Vec<ast::Ident>>();
// The `vi_idents` will be bound, solely in the catch-all, to
// a series of let statements mapping each self_arg to a uint
// corresponding to its variant index.
let vi_idents: Vec<ast::Ident> = self_arg_names.iter()
- .map(|name| { let vi_suffix = format!("{}_vi", name[]);
- cx.ident_of(vi_suffix[]) })
+ .map(|name| { let vi_suffix = format!("{}_vi", name.index(&FullRange));
+ cx.ident_of(vi_suffix.index(&FullRange)) })
.collect::<Vec<ast::Ident>>();
// Builds, via callback to call_substructure_method, the
// delegated expression that handles the catch-all case,
// using `__variants_tuple` to drive logic if necessary.
let catch_all_substructure = EnumNonMatchingCollapsed(
- self_arg_idents, variants[], vi_idents[]);
+ self_arg_idents, variants.index(&FullRange), vi_idents.index(&FullRange));
// These arms are of the form:
// (Variant1, Variant1, ...) => Body1
let mut subpats = Vec::with_capacity(self_arg_names.len());
let mut self_pats_idents = Vec::with_capacity(self_arg_names.len() - 1);
let first_self_pat_idents = {
- let (p, idents) = mk_self_pat(cx, self_arg_names[0][]);
+ let (p, idents) = mk_self_pat(cx, self_arg_names[0].index(&FullRange));
subpats.push(p);
idents
};
for self_arg_name in self_arg_names.tail().iter() {
- let (p, idents) = mk_self_pat(cx, self_arg_name[]);
+ let (p, idents) = mk_self_pat(cx, self_arg_name.index(&FullRange));
subpats.push(p);
self_pats_idents.push(idents);
}
&**variant,
field_tuples);
let arm_expr = self.call_substructure_method(
- cx, trait_, type_ident, self_args[], nonself_args,
+ cx, trait_, type_ident, self_args.index(&FullRange), nonself_args,
&substructure);
cx.arm(sp, vec![single_pat], arm_expr)
let arms: Vec<ast::Arm> = variants.iter().enumerate()
.map(|(index, variant)| {
let pat = variant_to_pat(cx, sp, type_ident, &**variant);
- let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyU));
+ let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyUs));
cx.arm(sp, vec![pat], cx.expr_lit(sp, lit))
}).collect();
}
let arm_expr = self.call_substructure_method(
- cx, trait_, type_ident, self_args[], nonself_args,
+ cx, trait_, type_ident, self_args.index(&FullRange), nonself_args,
&catch_all_substructure);
// Builds the expression:
cx.span_bug(sp, "a struct with named and unnamed fields in `derive`");
}
};
- let ident = cx.ident_of(format!("{}_{}", prefix, i)[]);
+ let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange));
paths.push(codemap::Spanned{span: sp, node: ident});
let val = cx.expr(
sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident)))));
let mut ident_expr = Vec::new();
for (i, va) in variant_args.iter().enumerate() {
let sp = self.set_expn_info(cx, va.ty.span);
- let ident = cx.ident_of(format!("{}_{}", prefix, i)[]);
+ let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange));
let path1 = codemap::Spanned{span: sp, node: ident};
paths.push(path1);
let expr_path = cx.expr_path(cx.path_ident(sp, ident));
field.span,
old,
field.self_.clone(),
- field.other[])
+ field.other.index(&FullRange))
})
} else {
all_fields.iter().rev().fold(base, |old, field| {
field.span,
old,
field.self_.clone(),
- field.other[])
+ field.other.index(&FullRange))
})
}
},
EnumNonMatchingCollapsed(ref all_args, _, tuple) =>
- enum_nonmatch_f.call_mut((cx, trait_span, (all_args[], tuple),
- substructure.nonself_args)),
+ enum_nonmatch_f(cx, trait_span, (all_args.index(&FullRange), tuple),
+ substructure.nonself_args),
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span, "static function in `derive`")
}
f(cx, trait_span, called)
},
EnumNonMatchingCollapsed(ref all_self_args, _, tuple) =>
- enum_nonmatch_f.call_mut((cx, trait_span, (all_self_args[], tuple),
- substructure.nonself_args)),
+ enum_nonmatch_f(cx, trait_span, (all_self_args.index(&FullRange), tuple),
+ substructure.nonself_args),
StaticEnum(..) | StaticStruct(..) => {
cx.span_bug(trait_span, "static function in `derive`")
}
MetaWord(ref tname) => {
macro_rules! expand {
($func:path) => ($func(cx, titem.span, &**titem, item,
- |i| push.call_mut((i,))))
+ |i| push(i)))
}
match tname.get() {
cx.span_err(titem.span,
format!("unknown `derive` \
trait: `{}`",
- *tname)[]);
+ *tname).index(&FullRange));
}
};
}
for (i, field) in fields.iter().enumerate() {
if i != 0 { format_string.push_str(", "); }
- format_string.push_str("{}");
+ format_string.push_str("{:?}");
exprs.push(field.self_.clone());
}
let name = token::get_ident(field.name.unwrap());
format_string.push_str(" ");
format_string.push_str(name.get());
- format_string.push_str(": {}");
+ format_string.push_str(": {:?}");
exprs.push(field.self_.clone());
}
let formatter = substr.nonself_args[0].clone();
let meth = cx.ident_of("write_fmt");
- let s = token::intern_and_get_ident(format_string[]);
+ let s = token::intern_and_get_ident(format_string.index(&FullRange));
let format_string = cx.expr_str(span, s);
// phew, not our responsibility any more!
Some(v) => v
};
- let e = match os::getenv(var[]) {
+ let e = match os::getenv(var.index(&FullRange)) {
None => {
cx.expr_path(cx.path_all(sp,
true,
cx.ident_of("Some")),
vec!(cx.expr_str(sp,
token::intern_and_get_ident(
- s[]))))
+ s.index(&FullRange)))))
}
};
MacExpr::new(e)
None => {
token::intern_and_get_ident(format!("environment variable `{}` \
not defined",
- var)[])
+ var).index(&FullRange))
}
Some(second) => {
match expr_to_string(cx, second, "expected string literal") {
cx.span_err(sp, msg.get());
cx.expr_uint(sp, 0)
}
- Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s[]))
+ Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s.index(&FullRange)))
};
MacExpr::new(e)
}
fld: &mut MacroExpander,
impl_ty: Option<P<ast::Ty>>)
-> P<ast::Ty> {
- debug!("expanding type {} with impl_ty {}", t, impl_ty);
+ debug!("expanding type {:?} with impl_ty {:?}", t, impl_ty);
let t = match (t.node.clone(), impl_ty) {
// Expand uses of `Self` in impls to the concrete type.
(ast::Ty_::TyPath(ref path, _), Some(ref impl_ty)) => {
fld.cx.span_err(
pth.span,
format!("macro undefined: '{}!'",
- extnamestr.get())[]);
+ extnamestr.get()).index(&FullRange));
// let compilation continue
None
},
});
let fm = fresh_mark();
- let marked_before = mark_tts(tts[], fm);
+ let marked_before = mark_tts(tts.index(&FullRange), fm);
// The span that we pass to the expanders we want to
// be the root of the call stack. That's the most
let opt_parsed = {
let expanded = expandfun.expand(fld.cx,
mac_span,
- marked_before[]);
+ marked_before.index(&FullRange));
parse_thunk(expanded)
};
let parsed = match opt_parsed {
fld.cx.span_err(
pth.span,
format!("non-expression macro in expression position: {}",
- extnamestr.get()[]
- )[]);
+ extnamestr.get().index(&FullRange)
+ ).index(&FullRange));
return None;
}
};
fld.cx.span_err(
pth.span,
format!("'{}' is not a tt-style macro",
- extnamestr.get())[]);
+ extnamestr.get()).index(&FullRange));
None
}
}
if valid_ident {
fld.cx.mod_push(it.ident);
}
- let macro_use = contains_macro_use(fld, new_attrs[]);
+ let macro_use = contains_macro_use(fld, new_attrs.index(&FullRange));
let result = with_exts_frame!(fld.cx.syntax_env,
macro_use,
noop_fold_item(it, fld));
None => {
fld.cx.span_err(path_span,
format!("macro undefined: '{}!'",
- extnamestr)[]);
+ extnamestr).index(&FullRange));
// let compilation continue
return SmallVector::zero();
}
format!("macro {}! expects no ident argument, \
given '{}'",
extnamestr,
- token::get_ident(it.ident))[]);
+ token::get_ident(it.ident)).index(&FullRange));
return SmallVector::zero();
}
fld.cx.bt_push(ExpnInfo {
}
});
// mark before expansion:
- let marked_before = mark_tts(tts[], fm);
- expander.expand(fld.cx, it.span, marked_before[])
+ let marked_before = mark_tts(tts.index(&FullRange), fm);
+ expander.expand(fld.cx, it.span, marked_before.index(&FullRange))
}
IdentTT(ref expander, span) => {
if it.ident.name == parse::token::special_idents::invalid.name {
fld.cx.span_err(path_span,
format!("macro {}! expects an ident argument",
- extnamestr.get())[]);
+ extnamestr.get()).index(&FullRange));
return SmallVector::zero();
}
fld.cx.bt_push(ExpnInfo {
}
});
// mark before expansion:
- let marked_tts = mark_tts(tts[], fm);
+ let marked_tts = mark_tts(tts.index(&FullRange), fm);
expander.expand(fld.cx, it.span, it.ident, marked_tts)
}
MacroRulesTT => {
if it.ident.name == parse::token::special_idents::invalid.name {
fld.cx.span_err(path_span,
- format!("macro_rules! expects an ident argument")[]);
+ format!("macro_rules! expects an ident argument")
+ .index(&FullRange));
return SmallVector::zero();
}
fld.cx.bt_push(ExpnInfo {
_ => {
fld.cx.span_err(it.span,
format!("{}! is not legal in item position",
- extnamestr.get())[]);
+ extnamestr.get()).index(&FullRange));
return SmallVector::zero();
}
}
None => {
fld.cx.span_err(path_span,
format!("non-item macro in item position: {}",
- extnamestr.get())[]);
+ extnamestr.get()).index(&FullRange));
return SmallVector::zero();
}
};
None => {
fld.cx.span_err(pth.span,
format!("macro undefined: '{}!'",
- extnamestr)[]);
+ extnamestr).index(&FullRange));
// let compilation continue
return DummyResult::raw_pat(span);
}
});
let fm = fresh_mark();
- let marked_before = mark_tts(tts[], fm);
+ let marked_before = mark_tts(tts.index(&FullRange), fm);
let mac_span = fld.cx.original_span();
let expanded = match expander.expand(fld.cx,
mac_span,
- marked_before[]).make_pat() {
+ marked_before.index(&FullRange)).make_pat() {
Some(e) => e,
None => {
fld.cx.span_err(
format!(
"non-pattern macro in pattern position: {}",
extnamestr.get()
- )[]
+ ).index(&FullRange)
);
return DummyResult::raw_pat(span);
}
_ => {
fld.cx.span_err(span,
format!("{}! is not legal in pattern position",
- extnamestr.get())[]);
+ extnamestr.get()).index(&FullRange));
return DummyResult::raw_pat(span);
}
}
node: match node {
MacInvocTT(path, tts, ctxt) => {
MacInvocTT(self.fold_path(path),
- self.fold_tts(tts[]),
+ self.fold_tts(tts.index(&FullRange)),
mtwt::apply_mark(self.mark, ctxt))
}
},
let string = ident.get();
"xx" == string
}).collect();
- let cxbinds: &[&ast::Ident] = cxbinds[];
+ let cxbinds: &[&ast::Ident] = cxbinds.index(&FullRange);
let cxbind = match cxbinds {
[b] => b,
_ => panic!("expected just one binding for ext_cx")
_ => {
ecx.span_err(p.span,
format!("expected ident for named argument, found `{}`",
- p.this_token_to_string())[]);
+ p.this_token_to_string()).index(&FullRange));
return None;
}
};
Some(prev) => {
ecx.span_err(e.span,
format!("duplicate argument named `{}`",
- name)[]);
+ name).index(&FullRange));
ecx.parse_sess.span_diagnostic.span_note(prev.span, "previously here");
continue
}
let msg = format!("invalid reference to argument `{}` ({})",
arg, self.describe_num_args());
- self.ecx.span_err(self.fmtsp, msg[]);
+ self.ecx.span_err(self.fmtsp, msg.index(&FullRange));
return;
}
{
Some(e) => e.span,
None => {
let msg = format!("there is no argument named `{}`", name);
- self.ecx.span_err(self.fmtsp, msg[]);
+ self.ecx.span_err(self.fmtsp, msg.index(&FullRange));
return;
}
};
format!("argument redeclared with type `{}` when \
it was previously `{}`",
*ty,
- *cur)[]);
+ *cur).index(&FullRange));
}
(&Known(ref cur), _) => {
self.ecx.span_err(sp,
format!("argument used to format with `{}` was \
attempted to not be used for formatting",
- *cur)[]);
+ *cur).index(&FullRange));
}
(_, &Known(ref ty)) => {
self.ecx.span_err(sp,
format!("argument previously used as a format \
argument attempted to be used as `{}`",
- *ty)[]);
+ *ty).index(&FullRange));
}
(_, _) => {
self.ecx.span_err(sp, "argument declared with multiple formats");
/// Translate the accumulated string literals to a literal expression
fn trans_literal_string(&mut self) -> P<ast::Expr> {
let sp = self.fmtsp;
- let s = token::intern_and_get_ident(self.literal[]);
+ let s = token::intern_and_get_ident(self.literal.index(&FullRange));
self.literal.clear();
self.ecx.expr_str(sp, s)
}
None => continue // error already generated
};
- let name = self.ecx.ident_of(format!("__arg{}", i)[]);
+ let name = self.ecx.ident_of(format!("__arg{}", i).index(&FullRange));
pats.push(self.ecx.pat_ident(e.span, name));
locals.push(Context::format_arg(self.ecx, e.span, arg_ty,
self.ecx.expr_ident(e.span, name)));
};
let lname = self.ecx.ident_of(format!("__arg{}",
- *name)[]);
+ *name).index(&FullRange));
pats.push(self.ecx.pat_ident(e.span, lname));
names[self.name_positions[*name]] =
Some(Context::format_arg(self.ecx, e.span, arg_ty,
-> P<ast::Expr> {
let trait_ = match *ty {
Known(ref tyname) => {
- match tyname[] {
- "" => "Show",
+ match tyname.index(&FullRange) {
+ "" => "String",
"?" => "Show",
"e" => "LowerExp",
"E" => "UpperExp",
_ => {
ecx.span_err(sp,
format!("unknown format trait `{}`",
- *tyname)[]);
+ *tyname).index(&FullRange));
"Dummy"
}
}
}
if !parser.errors.is_empty() {
cx.ecx.span_err(cx.fmtsp, format!("invalid format string: {}",
- parser.errors.remove(0))[]);
+ parser.errors.remove(0)).index(&FullRange));
return DummyResult::raw_expr(sp);
}
if !cx.literal.is_empty() {
/// Extend a syntax context with a given mark and sctable (explicit memoization)
fn apply_mark_internal(m: Mrk, ctxt: SyntaxContext, table: &SCTable) -> SyntaxContext {
let key = (ctxt, m);
- * table.mark_memo.borrow_mut().entry(&key).get().unwrap_or_else(
+ * table.mark_memo.borrow_mut().entry(key).get().unwrap_or_else(
|vacant_entry|
vacant_entry.insert(idx_push(&mut *table.table.borrow_mut(), Mark(m, ctxt))))
}
table: &SCTable) -> SyntaxContext {
let key = (ctxt, id, to);
- * table.rename_memo.borrow_mut().entry(&key).get().unwrap_or_else(
+ * table.rename_memo.borrow_mut().entry(key).get().unwrap_or_else(
|vacant_entry|
vacant_entry.insert(idx_push(&mut *table.table.borrow_mut(), Rename(id, to, ctxt))))
}
pub fn display_sctable(table: &SCTable) {
error!("SC table:");
for (idx,val) in table.table.borrow().iter().enumerate() {
- error!("{:4} : {}",idx,val);
+ error!("{:4} : {:?}",idx,val);
}
}
}
// the internal function for computing marks
-// it's not clear to me whether it's better to use a [] mutable
+// it's not clear to me whether it's better to use a .index(&FullRange) mutable
// vector or a cons-list for this.
fn marksof_internal(ctxt: SyntaxContext,
stopname: Name,
);
}
- impl_to_source_int! { signed, int, TyI }
+ impl_to_source_int! { signed, int, TyIs }
impl_to_source_int! { signed, i8, TyI8 }
impl_to_source_int! { signed, i16, TyI16 }
impl_to_source_int! { signed, i32, TyI32 }
impl_to_source_int! { signed, i64, TyI64 }
- impl_to_source_int! { unsigned, uint, TyU }
+ impl_to_source_int! { unsigned, uint, TyUs }
impl_to_source_int! { unsigned, u8, TyU8 }
impl_to_source_int! { unsigned, u16, TyU16 }
impl_to_source_int! { unsigned, u32, TyU32 }
}
fn ids_ext(strs: Vec<String> ) -> Vec<ast::Ident> {
- strs.iter().map(|str| str_to_ident((*str)[])).collect()
+ strs.iter().map(|str| str_to_ident((*str).index(&FullRange))).collect()
}
fn id_ext(str: &str) -> ast::Ident {
for i in range(0, tt.len()) {
seq.push(tt.get_tt(i));
}
- mk_tts(cx, seq[])
+ mk_tts(cx, seq.index(&FullRange))
}
ast::TtToken(sp, ref tok) => {
let e_sp = cx.expr_ident(sp, id_ext("_sp"));
let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
let mut vector = vec!(stmt_let_sp, stmt_let_tt);
- vector.extend(mk_tts(cx, tts[]).into_iter());
+ vector.extend(mk_tts(cx, tts.index(&FullRange)).into_iter());
let block = cx.expr_block(
cx.block_all(sp,
Vec::new(),
let topmost = cx.original_span_in_file();
let loc = cx.codemap().lookup_char_pos(topmost.lo);
- let filename = token::intern_and_get_ident(loc.file.name[]);
+ let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange));
base::MacExpr::new(cx.expr_str(topmost, filename))
}
-> Box<base::MacResult+'static> {
let s = pprust::tts_to_string(tts);
base::MacExpr::new(cx.expr_str(sp,
- token::intern_and_get_ident(s[])))
+ token::intern_and_get_ident(s.index(&FullRange))))
}
pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
.connect("::");
base::MacExpr::new(cx.expr_str(
sp,
- token::intern_and_get_ident(string[])))
+ token::intern_and_get_ident(string.index(&FullRange))))
}
/// include! : parse the given file as an expr
let bytes = match File::open(&file).read_to_end() {
Err(e) => {
cx.span_err(sp,
- format!("couldn't read {}: {}",
+ format!("couldn't read {:?}: {}",
file.display(),
- e)[]);
+ e).index(&FullRange));
return DummyResult::expr(sp);
}
Ok(bytes) => bytes,
Ok(src) => {
// Add this input file to the code map to make it available as
// dependency information
- let filename = file.display().to_string();
- let interned = token::intern_and_get_ident(src[]);
+ let filename = format!("{:?}", file.display());
+ let interned = token::intern_and_get_ident(src.index(&FullRange));
cx.codemap().new_filemap(filename, src);
base::MacExpr::new(cx.expr_str(sp, interned))
}
Err(_) => {
cx.span_err(sp,
- format!("{} wasn't a utf-8 file",
- file.display())[]);
+ format!("{:?} wasn't a utf-8 file",
+ file.display()).index(&FullRange));
return DummyResult::expr(sp);
}
}
match File::open(&file).read_to_end() {
Err(e) => {
cx.span_err(sp,
- format!("couldn't read {}: {}", file.display(), e)[]);
+ format!("couldn't read {:?}: {}", file.display(), e).index(&FullRange));
return DummyResult::expr(sp);
}
Ok(bytes) => {
seq.num_captures
}
&TtDelimited(_, ref delim) => {
- count_names(delim.tts[])
+ count_names(delim.tts.index(&FullRange))
}
&TtToken(_, MatchNt(..)) => {
1
pub fn initial_matcher_pos(ms: Rc<Vec<TokenTree>>, sep: Option<Token>, lo: BytePos)
-> Box<MatcherPos> {
- let match_idx_hi = count_names(ms[]);
+ let match_idx_hi = count_names(ms.index(&FullRange));
let matches: Vec<_> = range(0, match_idx_hi).map(|_| Vec::new()).collect();
box MatcherPos {
stack: vec![],
}
}
&TtToken(sp, MatchNt(bind_name, _, _, _)) => {
- match ret_val.entry(&bind_name) {
+ match ret_val.entry(bind_name) {
Vacant(spot) => {
spot.insert(res[*idx].clone());
*idx += 1;
p_s.span_diagnostic
.span_fatal(sp,
format!("duplicated bind name: {}",
- string.get())[])
+ string.get()).index(&FullRange))
}
}
}
rdr: TtReader,
ms: Vec<TokenTree> )
-> HashMap<Ident, Rc<NamedMatch>> {
- match parse(sess, cfg, rdr, ms[]) {
+ match parse(sess, cfg, rdr, ms.index(&FullRange)) {
Success(m) => m,
Failure(sp, str) => {
- sess.span_diagnostic.span_fatal(sp, str[])
+ sess.span_diagnostic.span_fatal(sp, str.index(&FullRange))
}
Error(sp, str) => {
- sess.span_diagnostic.span_fatal(sp, str[])
+ sess.span_diagnostic.span_fatal(sp, str.index(&FullRange))
}
}
}
// Only touch the binders we have actually bound
for idx in range(ei.match_lo, ei.match_hi) {
let sub = (ei.matches[idx]).clone();
- new_pos.matches[idx]
+ (&mut new_pos.matches[idx])
.push(Rc::new(MatchedSeq(sub, mk_sp(ei.sp_lo,
sp.hi))));
}
new_ei.idx += 1u;
//we specifically matched zero repeats.
for idx in range(ei.match_cur, ei.match_cur + seq.num_captures) {
- new_ei.matches[idx].push(Rc::new(MatchedSeq(Vec::new(), sp)));
+ (&mut new_ei.matches[idx]).push(Rc::new(MatchedSeq(vec![], sp)));
}
cur_eis.push(new_ei);
if token_name_eq(&tok, &token::Eof) {
if eof_eis.len() == 1u {
let mut v = Vec::new();
- for dv in eof_eis[0].matches.iter_mut() {
+ for dv in (&mut eof_eis[0]).matches.iter_mut() {
v.push(dv.pop().unwrap());
}
- return Success(nameize(sess, ms, v[]));
+ return Success(nameize(sess, ms, v.index(&FullRange)));
} else if eof_eis.len() > 1u {
return Error(sp, "ambiguity: multiple successful parses".to_string());
} else {
TtToken(_, MatchNt(_, name, _, _)) => {
let name_string = token::get_ident(name);
let match_cur = ei.match_cur;
- ei.matches[match_cur].push(Rc::new(MatchedNonterminal(
+ (&mut ei.matches[match_cur]).push(Rc::new(MatchedNonterminal(
parse_nt(&mut rust_parser, name_string.get()))));
ei.idx += 1u;
ei.match_cur += 1;
}
pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
+ match name {
+ "tt" => {
+ p.quote_depth += 1u; //but in theory, non-quoted tts might be useful
+ let res = token::NtTT(P(p.parse_token_tree()));
+ p.quote_depth -= 1u;
+ return res;
+ }
+ _ => {}
+ }
+ // check at the beginning and the parser checks after each bump
+ p.check_unknown_macro_variable();
match name {
"item" => match p.parse_item(Vec::new()) {
Some(i) => token::NtItem(i),
_ => {
let token_str = pprust::token_to_string(&p.token);
p.fatal((format!("expected ident, found {}",
- token_str[]))[])
+ token_str.index(&FullRange))).index(&FullRange))
}
},
"path" => {
token::NtPath(box p.parse_path(LifetimeAndTypesWithoutColons))
}
"meta" => token::NtMeta(p.parse_meta_item()),
- "tt" => {
- p.quote_depth += 1u; //but in theory, non-quoted tts might be useful
- let res = token::NtTT(P(p.parse_token_tree()));
- p.quote_depth -= 1u;
- res
- }
_ => {
- p.fatal(format!("unsupported builtin nonterminal parser: {}", name)[])
+ p.fatal(format!("unsupported builtin nonterminal parser: {}", name).index(&FullRange))
}
}
}
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use ast::{Ident, TtDelimited, TtSequence, TtToken};
+use ast::{TokenTree, TtDelimited, TtSequence, TtToken};
use ast;
use codemap::{Span, DUMMY_SP};
use ext::base::{ExtCtxt, MacResult, SyntaxExtension};
use ext::tt::macro_parser::{Success, Error, Failure};
use ext::tt::macro_parser::{NamedMatch, MatchedSeq, MatchedNonterminal};
use ext::tt::macro_parser::{parse, parse_or_else};
-use parse::lexer::new_tt_reader;
+use parse::lexer::{new_tt_reader, new_tt_reader_with_doc_flag};
use parse::parser::Parser;
use parse::attr::ParserAttr;
-use parse::token::{special_idents, gensym_ident};
-use parse::token::{MatchNt, NtTT};
+use parse::token::{special_idents, gensym_ident, NtTT, Token};
+use parse::token::Token::*;
use parse::token;
use print;
use ptr::P;
following",
token_str);
let span = parser.span;
- parser.span_err(span, msg[]);
+ parser.span_err(span, msg.index(&FullRange));
}
}
}
}
struct MacroRulesMacroExpander {
- name: Ident,
- imported_from: Option<Ident>,
+ name: ast::Ident,
+ imported_from: Option<ast::Ident>,
lhses: Vec<Rc<NamedMatch>>,
rhses: Vec<Rc<NamedMatch>>,
}
self.name,
self.imported_from,
arg,
- self.lhses[],
- self.rhses[])
+ self.lhses.index(&FullRange),
+ self.rhses.index(&FullRange))
}
}
/// Given `lhses` and `rhses`, this is the new macro we create
fn generic_extension<'cx>(cx: &'cx ExtCtxt,
sp: Span,
- name: Ident,
- imported_from: Option<Ident>,
+ name: ast::Ident,
+ imported_from: Option<ast::Ident>,
arg: &[ast::TokenTree],
lhses: &[Rc<NamedMatch>],
rhses: &[Rc<NamedMatch>])
match **lhs {
MatchedNonterminal(NtTT(ref lhs_tt)) => {
let lhs_tt = match **lhs_tt {
- TtDelimited(_, ref delim) => delim.tts[],
+ TtDelimited(_, ref delim) => delim.tts.index(&FullRange),
_ => cx.span_fatal(sp, "malformed macro lhs")
};
// `None` is because we're not interpolating
- let mut arg_rdr = new_tt_reader(&cx.parse_sess().span_diagnostic,
- None,
- None,
- arg.iter()
- .map(|x| (*x).clone())
- .collect());
- arg_rdr.desugar_doc_comments = true;
+ let arg_rdr = new_tt_reader_with_doc_flag(&cx.parse_sess().span_diagnostic,
+ None,
+ None,
+ arg.iter()
+ .map(|x| (*x).clone())
+ .collect(),
+ true);
match parse(cx.parse_sess(), cx.cfg(), arg_rdr, lhs_tt) {
Success(named_matches) => {
let rhs = match *rhses[i] {
Some(named_matches),
imported_from,
rhs);
- let p = Parser::new(cx.parse_sess(), cx.cfg(), box trncbr);
+ let mut p = Parser::new(cx.parse_sess(), cx.cfg(), box trncbr);
+ p.check_unknown_macro_variable();
// Let the context choose how to interpret the result.
// Weird, but useful for X-macros.
return box ParserAnyMacro {
best_fail_spot = sp;
best_fail_msg = (*msg).clone();
},
- Error(sp, ref msg) => cx.span_fatal(sp, msg[])
+ Error(sp, ref msg) => cx.span_fatal(sp, msg.index(&FullRange))
}
}
_ => cx.bug("non-matcher found in parsed lhses")
}
}
- cx.span_fatal(best_fail_spot, best_fail_msg[]);
+ cx.span_fatal(best_fail_spot, best_fail_msg.index(&FullRange));
}
// Note that macro-by-example's input is also matched against a token tree:
_ => cx.span_bug(def.span, "wrong-structured lhs")
};
+ for lhs in lhses.iter() {
+ check_lhs_nt_follows(cx, &**lhs, def.span);
+ }
+
let rhses = match *argument_map[rhs_nm] {
MatchedSeq(ref s, _) => /* FIXME (#2543) */ (*s).clone(),
_ => cx.span_bug(def.span, "wrong-structured rhs")
NormalTT(exp, Some(def.span))
}
+
+fn check_lhs_nt_follows(cx: &mut ExtCtxt, lhs: &NamedMatch, sp: Span) {
+ // lhs is going to be like MatchedNonterminal(NtTT(TtDelimited(...))), where
+ // the entire lhs is those tts.
+ // if ever we get box/deref patterns, this could turn into an `if let
+ // &MatchedNonterminal(NtTT(box TtDelimited(...))) = lhs`
+ let matcher = match lhs {
+ &MatchedNonterminal(NtTT(ref inner)) => match &**inner {
+ &TtDelimited(_, ref tts) => tts.tts.as_slice(),
+ _ => cx.span_bug(sp, "wrong-structured lhs for follow check")
+ },
+ _ => cx.span_bug(sp, "wrong-structured lhs for follow check")
+ };
+
+ check_matcher(cx, matcher.iter(), &Eof);
+ // we don't abort on errors on rejection, the driver will do that for us
+ // after parsing/expansion. we can report every error in every macro this way.
+}
+
+// returns the last token that was checked, for TtSequence. this gets used later on.
+fn check_matcher<'a, I>(cx: &mut ExtCtxt, matcher: I, follow: &Token)
+-> Option<(Span, Token)> where I: Iterator<Item=&'a TokenTree> {
+ use print::pprust::token_to_string;
+
+ let mut last = None;
+
+ // 2. For each token T in M:
+ let mut tokens = matcher.peekable();
+ while let Some(token) = tokens.next() {
+ last = match *token {
+ TtToken(sp, MatchNt(ref name, ref frag_spec, _, _)) => {
+ // ii. If T is a simple NT, look ahead to the next token T' in
+ // M.
+ let next_token = match tokens.peek() {
+ // If T' closes a complex NT, replace T' with F
+ Some(&&TtToken(_, CloseDelim(_))) => follow.clone(),
+ Some(&&TtToken(_, ref tok)) => tok.clone(),
+ Some(&&TtSequence(sp, _)) => {
+ cx.span_err(sp,
+ format!("`${0}:{1}` is followed by a \
+ sequence repetition, which is not \
+ allowed for `{1}` fragments",
+ name.as_str(), frag_spec.as_str())
+ .as_slice());
+ Eof
+ },
+ // die next iteration
+ Some(&&TtDelimited(_, ref delim)) => delim.close_token(),
+ // else, we're at the end of the macro or sequence
+ None => follow.clone()
+ };
+
+ let tok = if let TtToken(_, ref tok) = *token { tok } else { unreachable!() };
+ // If T' is in the set FOLLOW(NT), continue. Else, reject.
+ match &next_token {
+ &Eof => return Some((sp, tok.clone())),
+ _ if is_in_follow(cx, &next_token, frag_spec.as_str()) => continue,
+ next => {
+ cx.span_err(sp, format!("`${0}:{1}` is followed by `{2}`, which \
+ is not allowed for `{1}` fragments",
+ name.as_str(), frag_spec.as_str(),
+ token_to_string(next)).as_slice());
+ continue
+ },
+ }
+ },
+ TtSequence(sp, ref seq) => {
+ // iii. Else, T is a complex NT.
+ match seq.separator {
+ // If T has the form $(...)U+ or $(...)U* for some token U,
+ // run the algorithm on the contents with F set to U. If it
+ // accepts, continue, else, reject.
+ Some(ref u) => {
+ let last = check_matcher(cx, seq.tts.iter(), u);
+ match last {
+ // Since the delimiter isn't required after the last
+ // repetition, make sure that the *next* token is
+ // sane. This doesn't actually compute the FIRST of
+ // the rest of the matcher yet, it only considers
+ // single tokens and simple NTs. This is imprecise,
+ // but conservatively correct.
+ Some((span, tok)) => {
+ let fol = match tokens.peek() {
+ Some(&&TtToken(_, ref tok)) => tok.clone(),
+ Some(&&TtDelimited(_, ref delim)) => delim.close_token(),
+ Some(_) => {
+ cx.span_err(sp, "sequence repetition followed by \
+ another sequence repetition, which is not allowed");
+ Eof
+ },
+ None => Eof
+ };
+ check_matcher(cx, Some(&TtToken(span, tok.clone())).into_iter(),
+ &fol)
+ },
+ None => last,
+ }
+ },
+ // If T has the form $(...)+ or $(...)*, run the algorithm
+ // on the contents with F set to the token following the
+ // sequence. If it accepts, continue, else, reject.
+ None => {
+ let fol = match tokens.peek() {
+ Some(&&TtToken(_, ref tok)) => tok.clone(),
+ Some(&&TtDelimited(_, ref delim)) => delim.close_token(),
+ Some(_) => {
+ cx.span_err(sp, "sequence repetition followed by another \
+ sequence repetition, which is not allowed");
+ Eof
+ },
+ None => Eof
+ };
+ check_matcher(cx, seq.tts.iter(), &fol)
+ }
+ }
+ },
+ TtToken(..) => {
+ // i. If T is not an NT, continue.
+ continue
+ },
+ TtDelimited(_, ref tts) => {
+ // if we don't pass in that close delimiter, we'll incorrectly consider the matcher
+ // `{ $foo:ty }` as having a follow that isn't `RBrace`
+ check_matcher(cx, tts.tts.iter(), &tts.close_token())
+ }
+ }
+ }
+ last
+}
+
+fn is_in_follow(cx: &ExtCtxt, tok: &Token, frag: &str) -> bool {
+ if let &CloseDelim(_) = tok {
+ return true;
+ }
+
+ match frag {
+ "item" => {
+ // since items *must* be followed by either a `;` or a `}`, we can
+ // accept anything after them
+ true
+ },
+ "block" => {
+ // anything can follow block, the braces provide a easy boundary to
+ // maintain
+ true
+ },
+ "stmt" | "expr" => {
+ match *tok {
+ FatArrow | Comma | Semi => true,
+ _ => false
+ }
+ },
+ "pat" => {
+ match *tok {
+ FatArrow | Comma | Eq => true,
+ _ => false
+ }
+ },
+ "path" | "ty" => {
+ match *tok {
+ Comma | FatArrow | Colon | Eq | Gt => true,
+ Ident(i, _) if i.as_str() == "as" => true,
+ _ => false
+ }
+ },
+ "ident" => {
+ // being a single token, idents are harmless
+ true
+ },
+ "meta" | "tt" => {
+ // being either a single token or a delimited sequence, tt is
+ // harmless
+ true
+ },
+ _ => cx.bug(format!("unrecognized builtin nonterminal {}",
+ frag).as_slice()),
+ }
+}
}
/// This can do Macro-By-Example transcription. On the other hand, if
-/// `src` contains no `TtSequence`s and `TtNonterminal`s, `interp` can (and
-/// should) be none.
+/// `src` contains no `TtSequence`s, `MatchNt`s or `SubstNt`s, `interp` can
+/// (and should) be None.
pub fn new_tt_reader<'a>(sp_diag: &'a SpanHandler,
interp: Option<HashMap<Ident, Rc<NamedMatch>>>,
imported_from: Option<Ident>,
- src: Vec<ast::TokenTree> )
+ src: Vec<ast::TokenTree>)
-> TtReader<'a> {
+ new_tt_reader_with_doc_flag(sp_diag, interp, imported_from, src, false)
+}
+
+/// The extra `desugar_doc_comments` flag enables reading doc comments
+/// like any other attribute which consists of `meta` and surrounding #[ ] tokens.
+///
+/// This can do Macro-By-Example transcription. On the other hand, if
+/// `src` contains no `TtSequence`s, `MatchNt`s or `SubstNt`s, `interp` can
+/// (and should) be None.
+pub fn new_tt_reader_with_doc_flag<'a>(sp_diag: &'a SpanHandler,
+ interp: Option<HashMap<Ident, Rc<NamedMatch>>>,
+ imported_from: Option<Ident>,
+ src: Vec<ast::TokenTree>,
+ desugar_doc_comments: bool)
+ -> TtReader<'a> {
let mut r = TtReader {
sp_diag: sp_diag,
stack: vec!(TtFrame {
crate_name_next: None,
repeat_idx: Vec::new(),
repeat_len: Vec::new(),
- desugar_doc_comments: false,
+ desugar_doc_comments: desugar_doc_comments,
/* dummy values, never read: */
cur_tok: token::Eof,
cur_span: DUMMY_SP,
let l_n = token::get_ident(l_id.clone());
let r_n = token::get_ident(r_id);
LisContradiction(format!("inconsistent lockstep iteration: \
- '{}' has {} items, but '{}' has {}",
+ '{:?}' has {} items, but '{:?}' has {}",
l_n, l_len, r_n, r_len).to_string())
}
},
}
LisContradiction(ref msg) => {
// FIXME #2887 blame macro invoker instead
- r.sp_diag.span_fatal(sp.clone(), msg[]);
+ r.sp_diag.span_fatal(sp.clone(), msg.index(&FullRange));
}
LisConstraint(len, _) => {
if len == 0 {
}
// FIXME #2887: think about span stuff here
TtToken(sp, SubstNt(ident, namep)) => {
+ r.stack.last_mut().unwrap().idx += 1;
match lookup_cur_matched(r, ident) {
None => {
- r.stack.push(TtFrame {
- forest: TtToken(sp, SubstNt(ident, namep)),
- idx: 0,
- dotdotdoted: false,
- sep: None
- });
+ r.cur_span = sp;
+ r.cur_tok = SubstNt(ident, namep);
+ return ret_val;
// this can't be 0 length, just like TtDelimited
}
Some(cur_matched) => {
- r.stack.last_mut().unwrap().idx += 1;
match *cur_matched {
// sidestep the interpolation tricks for ident because
// (a) idents can be in lots of places, so it'd be a pain
MatchedSeq(..) => {
r.sp_diag.span_fatal(
r.cur_span, /* blame the macro writer */
- format!("variable '{}' is still repeating at this depth",
- token::get_ident(ident))[]);
+ format!("variable '{:?}' is still repeating at this depth",
+ token::get_ident(ident)).index(&FullRange));
}
}
}
("non_ascii_idents", Active),
("thread_local", Active),
("link_args", Active),
- ("phase", Active), // NOTE(stage0): switch to Removed after next snapshot
+ ("phase", Removed),
("plugin_registrar", Active),
("log_syntax", Active),
("trace_macros", Active),
// A way to temporarily opt out of the new orphan rules. This will *never* be accepted.
("old_orphan_check", Deprecated),
+ // A way to temporarily opt out of the new impl rules. This will *never* be accepted.
+ ("old_impl_check", Deprecated),
+
// OIBIT specific features
("optin_builtin_traits", Active),
self.span_handler.span_err(span, explain);
self.span_handler.span_help(span, format!("add #![feature({})] to the \
crate attributes to enable",
- feature)[]);
+ feature).index(&FullRange));
}
}
}
match i.node {
ast::ItemForeignMod(ref foreign_module) => {
- if attr::contains_name(i.attrs[], "link_args") {
+ if attr::contains_name(i.attrs.index(&FullRange), "link_args") {
self.gate_feature("link_args", i.span,
"the `link_args` attribute is not portable \
across platforms, it is recommended to \
}
ast::ItemFn(..) => {
- if attr::contains_name(i.attrs[], "plugin_registrar") {
+ if attr::contains_name(i.attrs.index(&FullRange), "plugin_registrar") {
self.gate_feature("plugin_registrar", i.span,
"compiler plugins are experimental and possibly buggy");
}
}
ast::ItemStruct(..) => {
- if attr::contains_name(i.attrs[], "simd") {
+ if attr::contains_name(i.attrs.index(&FullRange), "simd") {
self.gate_feature("simd", i.span,
"SIMD types are experimental and possibly buggy");
}
_ => {}
}
- if attr::contains_name(i.attrs[],
+ if attr::contains_name(i.attrs.as_slice(),
"unsafe_destructor") {
self.gate_feature("unsafe_destructor",
i.span,
removed in the future");
}
- if attr::contains_name(i.attrs[],
+ if attr::contains_name(i.attrs.index(&FullRange),
"old_orphan_check") {
self.gate_feature(
"old_orphan_check",
i.span,
"the new orphan check rules will eventually be strictly enforced");
}
+
+ if attr::contains_name(i.attrs.index(&FullRange),
+ "old_impl_check") {
+ self.gate_feature("old_impl_check",
+ i.span,
+ "`#[old_impl_check]` will be removed in the future");
+ }
}
_ => {}
}
fn visit_foreign_item(&mut self, i: &ast::ForeignItem) {
- if attr::contains_name(i.attrs[], "linkage") {
+ if attr::contains_name(i.attrs.index(&FullRange), "linkage") {
self.gate_feature("linkage", i.span,
"the `linkage` attribute is experimental \
and not portable across platforms")
}
- let links_to_llvm = match attr::first_attr_value_str_by_name(i.attrs[], "link_name") {
+ let links_to_llvm = match attr::first_attr_value_str_by_name(i.attrs.as_slice(),
+ "link_name") {
Some(val) => val.get().starts_with("llvm."),
_ => false
};
html_root_url = "http://doc.rust-lang.org/nightly/")]
#![allow(unknown_features)]
-#![feature(macro_rules, globs, default_type_params, phase, slicing_syntax)]
+#![feature(slicing_syntax)]
#![feature(quote, unsafe_destructor)]
-#![feature(unboxed_closures)]
-#![feature(old_orphan_check)]
-#![feature(associated_types)]
extern crate arena;
extern crate fmt_macros;
extern crate serialize;
extern crate term;
extern crate libc;
-
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
+#[macro_use] extern crate log;
extern crate "serialize" as rustc_serialize; // used by deriving
}
}
-#[cfg(stage0)]
-impl<S: Encoder<E>, T: Encodable<S, E>, E> Encodable<S, E> for OwnedSlice<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- self.as_slice().encode(s)
- }
-}
-
-#[cfg(not(stage0))]
impl<T: Encodable> Encodable for OwnedSlice<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
self.as_slice().encode(s)
}
}
-#[cfg(stage0)]
-impl<D: Decoder<E>, T: Decodable<D, E>, E> Decodable<D, E> for OwnedSlice<T> {
- fn decode(d: &mut D) -> Result<OwnedSlice<T>, E> {
- Ok(OwnedSlice::from_vec(match Decodable::decode(d) {
- Ok(t) => t,
- Err(e) => return Err(e)
- }))
- }
-}
-
-#[cfg(not(stage0))]
impl<T: Decodable> Decodable for OwnedSlice<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<OwnedSlice<T>, D::Error> {
Ok(OwnedSlice::from_vec(match Decodable::decode(d) {
fn parse_outer_attributes(&mut self) -> Vec<ast::Attribute> {
let mut attrs: Vec<ast::Attribute> = Vec::new();
loop {
- debug!("parse_outer_attributes: self.token={}",
+ debug!("parse_outer_attributes: self.token={:?}",
self.token);
match self.token {
token::Pound => {
/// If permit_inner is true, then a leading `!` indicates an inner
/// attribute
fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute {
- debug!("parse_attributes: permit_inner={} self.token={}",
+ debug!("parse_attributes: permit_inner={:?} self.token={:?}",
permit_inner, self.token);
let (span, value, mut style) = match self.token {
token::Pound => {
}
_ => {
let token_str = self.this_token_to_string();
- self.fatal(format!("expected `#`, found `{}`", token_str)[]);
+ self.fatal(format!("expected `#`, found `{}`", token_str).index(&FullRange));
}
};
while j > i && lines[j - 1].trim().is_empty() {
j -= 1;
}
- return lines[i..j].iter().map(|x| (*x).clone()).collect();
+ return lines.index(&(i..j)).iter().map(|x| (*x).clone()).collect();
}
/// remove a "[ \t]*\*" block from each line, if possible
if can_trim {
lines.iter().map(|line| {
- line[i + 1..line.len()].to_string()
+ line.index(&((i + 1)..line.len())).to_string()
}).collect()
} else {
lines
static ONLINERS: &'static [&'static str] = &["///!", "///", "//!", "//"];
for prefix in ONLINERS.iter() {
if comment.starts_with(*prefix) {
- return comment[prefix.len()..].to_string();
+ return comment.index(&(prefix.len()..)).to_string();
}
}
if comment.starts_with("/*") {
- let lines = comment[3u..comment.len() - 2u]
+ let lines = comment.index(&(3u..(comment.len() - 2u)))
.lines_any()
.map(|s| s.to_string())
.collect::<Vec<String> >();
let line = rdr.read_one_line_comment();
debug!("{}", line);
// Doc comments are not put in comments.
- if is_doc_comment(line[]) {
+ if is_doc_comment(line.index(&FullRange)) {
break;
}
lines.push(line);
fn trim_whitespace_prefix_and_push_line(lines: &mut Vec<String> ,
s: String, col: CharPos) {
let len = s.len();
- let s1 = match all_whitespace(s[], col) {
+ let s1 = match all_whitespace(s.index(&FullRange), col) {
Some(col) => {
if col < len {
- s[col..len].to_string()
+ s.index(&(col..len)).to_string()
} else {
"".to_string()
}
rdr.bump();
rdr.bump();
}
- if is_block_doc_comment(curr_line[]) {
+ if is_block_doc_comment(curr_line.index(&FullRange)) {
return
}
assert!(!curr_line.contains_char('\n'));
use std::str;
use std::string::CowString;
-pub use ext::tt::transcribe::{TtReader, new_tt_reader};
+pub use ext::tt::transcribe::{TtReader, new_tt_reader, new_tt_reader_with_doc_flag};
pub mod comments;
}
fn next_token(&mut self) -> TokenAndSpan {
let r = tt_next_token(self);
- debug!("TtReader: r={}", r);
+ debug!("TtReader: r={:?}", r);
r
}
fn fatal(&self, m: &str) -> ! {
let mut m = m.to_string();
m.push_str(": ");
for c in c.escape_default() { m.push(c) }
- self.fatal_span_(from_pos, to_pos, m[]);
+ self.fatal_span_(from_pos, to_pos, m.index(&FullRange));
}
/// Report a lexical error spanning [`from_pos`, `to_pos`), appending an
let mut m = m.to_string();
m.push_str(": ");
for c in c.escape_default() { m.push(c) }
- self.err_span_(from_pos, to_pos, m[]);
+ self.err_span_(from_pos, to_pos, m.index(&FullRange));
}
/// Report a lexical error spanning [`from_pos`, `to_pos`), appending the
m.push_str(": ");
let from = self.byte_offset(from_pos).to_uint();
let to = self.byte_offset(to_pos).to_uint();
- m.push_str(self.filemap.src[from..to]);
- self.fatal_span_(from_pos, to_pos, m[]);
+ m.push_str(self.filemap.src.index(&(from..to)));
+ self.fatal_span_(from_pos, to_pos, m.index(&FullRange));
}
/// Advance peek_tok and peek_span to refer to the next token, and
/// adjusted 1 towards each other (assumes that on either side there is a
/// single-byte delimiter).
pub fn name_from(&self, start: BytePos) -> ast::Name {
- debug!("taking an ident from {} to {}", start, self.last_pos);
+ debug!("taking an ident from {:?} to {:?}", start, self.last_pos);
self.with_str_from(start, token::intern)
}
/// As name_from, with an explicit endpoint.
pub fn name_from_to(&self, start: BytePos, end: BytePos) -> ast::Name {
- debug!("taking an ident from {} to {}", start, end);
+ debug!("taking an ident from {:?} to {:?}", start, end);
self.with_str_from_to(start, end, token::intern)
}
while i < s.len() {
let str::CharRange { ch, next } = s.char_range_at(i);
if ch == '\r' {
- if j < i { buf.push_str(s[j..i]); }
+ if j < i { buf.push_str(s.index(&(j..i))); }
j = next;
if next >= s.len() || s.char_at(next) != '\n' {
let pos = start + BytePos(i as u32);
}
i = next;
}
- if j < s.len() { buf.push_str(s[j..]); }
+ if j < s.len() { buf.push_str(s.index(&(j..))); }
buf
}
}
// for skipping over all "junk"
'/' | '#' => {
let c = self.scan_comment();
- debug!("scanning a comment {}", c);
+ debug!("scanning a comment {:?}", c);
c
},
c if is_whitespace(Some(c)) => {
tok: token::Whitespace,
sp: codemap::mk_sp(start_bpos, self.last_pos)
});
- debug!("scanning whitespace: {}", c);
+ debug!("scanning whitespace: {:?}", c);
c
},
_ => None
self.translate_crlf(start_bpos, string,
"bare CR not allowed in block doc-comment")
} else { string.into_cow() };
- token::DocComment(token::intern(string[]))
+ token::DocComment(token::intern(string.index(&FullRange)))
} else {
token::Comment
};
whence: &str) {
match r.curr {
Some(r_c) if r_c == c => r.bump(),
- Some(r_c) => panic!("expected {}, hit {}, {}", described_c, r_c, whence),
- None => panic!("expected {}, hit EOF, {}", described_c, whence),
+ Some(r_c) => panic!("expected {:?}, hit {:?}, {}", described_c, r_c, whence),
+ None => panic!("expected {:?}, hit EOF, {}", described_c, whence),
}
}
self.scan_digits(base);
let encoded_name : u32 = self.with_str_from(start_bpos, |s| {
num::from_str_radix(s, 10).unwrap_or_else(|| {
- panic!("expected digits representing a name, got `{}`, {}, range [{},{}]",
+ panic!("expected digits representing a name, got {:?}, {}, range [{:?},{:?}]",
s, whence, start_bpos, self.last_pos);
})
});
self.scan_digits(base);
let encoded_ctxt : ast::SyntaxContext = self.with_str_from(start_bpos, |s| {
num::from_str_radix(s, 10).unwrap_or_else(|| {
- panic!("expected digits representing a ctxt, got `{}`, {}", s, whence);
+ panic!("expected digits representing a ctxt, got {:?}, {}", s, whence);
})
});
if c == Some('_') { debug!("skipping a _"); self.bump(); continue; }
match c.and_then(|cc| cc.to_digit(radix)) {
Some(_) => {
- debug!("{} in scan_digits", c);
+ debug!("{:?} in scan_digits", c);
len += 1;
self.bump();
}
delim: char,
below_0x7f_only: bool)
-> bool {
- debug!("scanning {} digits until {}", n_digits, delim);
+ debug!("scanning {} digits until {:?}", n_digits, delim);
let start_bpos = self.last_pos;
let mut accum_int = 0;
if is_dec_digit(c) {
let num = self.scan_number(c.unwrap());
let suffix = self.scan_optional_raw_name();
- debug!("next_token_inner: scanned number {}, {}", num, suffix);
+ debug!("next_token_inner: scanned number {:?}, {:?}", num, suffix);
return token::Literal(num, suffix)
}
// expansion purposes. See #12512 for the gory details of why
// this is necessary.
let ident = self.with_str_from(start, |lifetime_name| {
- str_to_ident(format!("'{}", lifetime_name)[])
+ str_to_ident(format!("'{}", lifetime_name).index(&FullRange))
});
// Conjure up a "keyword checking ident" to make sure that
pub fn is_doc_comment(s: &str) -> bool {
let res = (s.starts_with("///") && *s.as_bytes().get(3).unwrap_or(&b' ') != b'/')
|| s.starts_with("//!");
- debug!("is `{}` a doc comment? {}", s, res);
+ debug!("is {:?} a doc comment? {}", s, res);
res
}
pub fn is_block_doc_comment(s: &str) -> bool {
let res = (s.starts_with("/**") && *s.as_bytes().get(3).unwrap_or(&b' ') != b'*')
|| s.starts_with("/*!");
- debug!("is `{}` a doc comment? {}", s, res);
+ debug!("is {:?} a doc comment? {}", s, res);
res
}
use std::str;
use std::iter;
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
pub mod parser;
pub mod lexer;
let bytes = match File::open(path).read_to_end() {
Ok(bytes) => bytes,
Err(e) => {
- err(format!("couldn't read {}: {}",
+ err(format!("couldn't read {:?}: {:?}",
path.display(),
- e)[]);
+ e).index(&FullRange));
unreachable!()
}
};
- match str::from_utf8(bytes[]).ok() {
+ match str::from_utf8(bytes.index(&FullRange)).ok() {
Some(s) => {
return string_to_filemap(sess, s.to_string(),
path.as_str().unwrap().to_string())
}
None => {
- err(format!("{} is not UTF-8 encoded", path.display())[])
+ err(format!("{:?} is not UTF-8 encoded", path.display()).index(&FullRange))
}
}
unreachable!()
tts: Vec<ast::TokenTree>,
cfg: ast::CrateConfig) -> Parser<'a> {
let trdr = lexer::new_tt_reader(&sess.span_diagnostic, None, None, tts);
- Parser::new(sess, cfg, box trdr)
+ let mut p = Parser::new(sess, cfg, box trdr);
+ p.check_unknown_macro_variable();
+ p
}
// FIXME (Issue #16472): The `with_hygiene` mod should go away after
}
let msg = format!("lexer should have rejected a bad character escape {}", lit);
- let msg2 = msg[];
+ let msg2 = msg.index(&FullRange);
fn esc(len: uint, lit: &str) -> Option<(char, int)> {
- num::from_str_radix(lit[2..len], 16)
+ num::from_str_radix(lit.index(&(2..len)), 16)
.and_then(char::from_u32)
.map(|x| (x, len as int))
}
let unicode_escape = |&: | -> Option<(char, int)>
if lit.as_bytes()[2] == b'{' {
let idx = lit.find('}').expect(msg2);
- let subslice = lit[3..idx];
+ let subslice = lit.index(&(3..idx));
num::from_str_radix(subslice, 16)
.and_then(char::from_u32)
.map(|x| (x, subslice.chars().count() as int + 4))
eat(&mut chars);
} else {
// otherwise, a normal escape
- let (c, n) = char_lit(lit[i..]);
+ let (c, n) = char_lit(lit.index(&(i..)));
for _ in range(0, n - 1) { // we don't need to move past the first \
chars.next();
}
fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool {
s.len() > 1 &&
first_chars.contains(&s.char_at(0)) &&
- s[1..].chars().all(|c| '0' <= c && c <= '9')
+ s.index(&(1..)).chars().all(|c| '0' <= c && c <= '9')
}
fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
sd: &SpanHandler, sp: Span) -> ast::Lit_ {
- debug!("filtered_float_lit: {}, {}", data, suffix);
+ debug!("filtered_float_lit: {}, {:?}", data, suffix);
match suffix {
Some("f32") => ast::LitFloat(data, ast::TyF32),
Some("f64") => ast::LitFloat(data, ast::TyF64),
if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
// if it looks like a width, lets try to be helpful.
sd.span_err(sp, &*format!("illegal width `{}` for float literal, \
- valid widths are 32 and 64", suf[1..]));
+ valid widths are 32 and 64", suf.index(&(1..))));
} else {
sd.span_err(sp, &*format!("illegal suffix `{}` for float literal, \
valid suffixes are `f32` and `f64`", suf));
}
}
pub fn float_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) -> ast::Lit_ {
- debug!("float_lit: {}, {}", s, suffix);
+ debug!("float_lit: {:?}, {:?}", s, suffix);
// FIXME #2252: bounds checking float literals is defered until trans
let s = s.chars().filter(|&c| c != '_').collect::<String>();
let data = token::intern_and_get_ident(&*s);
b'\'' => b'\'',
b'0' => b'\0',
_ => {
- match ::std::num::from_str_radix::<u64>(lit[2..4], 16) {
+ match ::std::num::from_str_radix::<u64>(lit.index(&(2..4)), 16) {
Some(c) =>
if c > 0xFF {
panic!(err(2))
}
_ => {
// otherwise, a normal escape
- let (c, n) = byte_lit(lit[i..]);
+ let (c, n) = byte_lit(lit.index(&(i..)));
// we don't need to move past the first \
for _ in range(0, n - 1) {
chars.next();
// s can only be ascii, byte indexing is fine
let s2 = s.chars().filter(|&c| c != '_').collect::<String>();
- let mut s = s2[];
+ let mut s = s2.index(&FullRange);
- debug!("integer_lit: {}, {}", s, suffix);
+ debug!("integer_lit: {}, {:?}", s, suffix);
let mut base = 10;
let orig = s;
}
if base != 10 {
- s = s[2..];
+ s = s.index(&(2..));
}
if let Some(suf) = suffix {
if suf.is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")}
ty = match suf {
- "i" => ast::SignedIntLit(ast::TyI, ast::Plus),
+ "i" => ast::SignedIntLit(ast::TyIs, ast::Plus),
+ "is" => ast::SignedIntLit(ast::TyIs, ast::Plus),
"i8" => ast::SignedIntLit(ast::TyI8, ast::Plus),
"i16" => ast::SignedIntLit(ast::TyI16, ast::Plus),
"i32" => ast::SignedIntLit(ast::TyI32, ast::Plus),
"i64" => ast::SignedIntLit(ast::TyI64, ast::Plus),
- "u" => ast::UnsignedIntLit(ast::TyU),
+ "u" => ast::UnsignedIntLit(ast::TyUs),
+ "us" => ast::UnsignedIntLit(ast::TyUs),
"u8" => ast::UnsignedIntLit(ast::TyU8),
"u16" => ast::UnsignedIntLit(ast::TyU16),
"u32" => ast::UnsignedIntLit(ast::TyU32),
if looks_like_width_suffix(&['i', 'u'], suf) {
sd.span_err(sp, &*format!("illegal width `{}` for integer literal; \
valid widths are 8, 16, 32 and 64",
- suf[1..]));
+ suf.index(&(1..))));
} else {
sd.span_err(sp, &*format!("illegal suffix `{}` for numeric literal", suf));
}
}
}
- debug!("integer_lit: the type is {}, base {}, the new string is {}, the original \
- string was {}, the original suffix was {}", ty, base, s, orig, suffix);
+ debug!("integer_lit: the type is {:?}, base {:?}, the new string is {:?}, the original \
+ string was {:?}, the original suffix was {:?}", ty, base, s, orig, suffix);
let res: u64 = match ::std::num::from_str_radix(s, base) {
Some(r) => r,
#[test]
fn string_to_tts_macro () {
let tts = string_to_tts("macro_rules! zip (($a)=>($a))".to_string());
- let tts: &[ast::TokenTree] = tts[];
+ let tts: &[ast::TokenTree] = tts.index(&FullRange);
match tts {
[ast::TtToken(_, token::Ident(name_macro_rules, token::Plain)),
ast::TtToken(_, token::Not),
ast::TtDelimited(_, ref macro_delimed)]
if name_macro_rules.as_str() == "macro_rules"
&& name_zip.as_str() == "zip" => {
- match macro_delimed.tts[] {
+ match macro_delimed.tts.index(&FullRange) {
[ast::TtDelimited(_, ref first_delimed),
ast::TtToken(_, token::FatArrow),
ast::TtDelimited(_, ref second_delimed)]
if macro_delimed.delim == token::Paren => {
- match first_delimed.tts[] {
+ match first_delimed.tts.index(&FullRange) {
[ast::TtToken(_, token::Dollar),
ast::TtToken(_, token::Ident(name, token::Plain))]
if first_delimed.delim == token::Paren
&& name.as_str() == "a" => {},
- _ => panic!("value 3: {}", **first_delimed),
+ _ => panic!("value 3: {:?}", **first_delimed),
}
- match second_delimed.tts[] {
+ match second_delimed.tts.index(&FullRange) {
[ast::TtToken(_, token::Dollar),
ast::TtToken(_, token::Ident(name, token::Plain))]
if second_delimed.delim == token::Paren
&& name.as_str() == "a" => {},
- _ => panic!("value 4: {}", **second_delimed),
+ _ => panic!("value 4: {:?}", **second_delimed),
}
},
- _ => panic!("value 2: {}", **macro_delimed),
+ _ => panic!("value 2: {:?}", **macro_delimed),
}
},
- _ => panic!("value: {}",tts),
+ _ => panic!("value: {:?}",tts),
}
}
let use_s = "use foo::bar::baz;";
let vitem = string_to_view_item(use_s.to_string());
let vitem_s = view_item_to_string(&vitem);
- assert_eq!(vitem_s[], use_s);
+ assert_eq!(vitem_s.index(&FullRange), use_s);
let use_s = "use foo::bar as baz;";
let vitem = string_to_view_item(use_s.to_string());
let vitem_s = view_item_to_string(&vitem);
- assert_eq!(vitem_s[], use_s);
+ assert_eq!(vitem_s.index(&FullRange), use_s);
}
#[test] fn parse_extern_crate() {
let ex_s = "extern crate foo;";
let vitem = string_to_view_item(ex_s.to_string());
let vitem_s = view_item_to_string(&vitem);
- assert_eq!(vitem_s[], ex_s);
+ assert_eq!(vitem_s.index(&FullRange), ex_s);
let ex_s = "extern crate \"foo\" as bar;";
let vitem = string_to_view_item(ex_s.to_string());
let vitem_s = view_item_to_string(&vitem);
- assert_eq!(vitem_s[], ex_s);
+ assert_eq!(vitem_s.index(&FullRange), ex_s);
}
fn get_spans_of_pat_idents(src: &str) -> Vec<Span> {
for &src in srcs.iter() {
let spans = get_spans_of_pat_idents(src);
- let Span{lo:lo,hi:hi,..} = spans[0];
- assert!("self" == src[lo.to_uint()..hi.to_uint()],
+ let Span{ lo, hi, .. } = spans[0];
+ assert!("self" == &src[lo.to_uint()..hi.to_uint()],
"\"{}\" != \"self\". src=\"{}\"",
- src[lo.to_uint()..hi.to_uint()], src)
+ &src[lo.to_uint()..hi.to_uint()], src)
}
}
let docs = item.attrs.iter().filter(|a| a.name().get() == "doc")
.map(|a| a.value_str().unwrap().get().to_string()).collect::<Vec<_>>();
let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()];
- assert_eq!(docs[], b);
+ assert_eq!(docs.index(&FullRange), b);
let source = "/** doc comment\r\n * with CRLF */\r\nfn foo() {}".to_string();
let item = parse_item_from_source_str(name, source, Vec::new(), &sess).unwrap();
kind_str: &str,
desc: &str) {
self.span_err(sp,
- format!("obsolete syntax: {}", kind_str)[]);
+ format!("obsolete syntax: {}", kind_str).index(&FullRange));
if !self.obsolete_set.contains(&kind) {
self.sess
.span_diagnostic
.handler()
- .note(format!("{}", desc)[]);
+ .note(format!("{}", desc).index(&FullRange));
self.obsolete_set.insert(kind);
}
}
use ast::{Visibility, WhereClause};
use ast;
use ast_util::{self, as_prec, ident_to_path, operator_prec};
-use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, DUMMY_SP};
+use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp};
use diagnostic;
use ext::tt::macro_parser;
use parse;
let token_str = Parser::token_to_string(t);
let last_span = self.last_span;
self.span_fatal(last_span, format!("unexpected token: `{}`",
- token_str)[]);
+ token_str).index(&FullRange));
}
pub fn unexpected(&mut self) -> ! {
let this_token = self.this_token_to_string();
- self.fatal(format!("unexpected token: `{}`", this_token)[]);
+ self.fatal(format!("unexpected token: `{}`", this_token).index(&FullRange));
}
/// Expect and consume the token t. Signal an error if
let this_token_str = self.this_token_to_string();
self.fatal(format!("expected `{}`, found `{}`",
token_str,
- this_token_str)[])
+ this_token_str).index(&FullRange))
}
} else {
self.expect_one_of(slice::ref_slice(t), &[]);
expected.push_all(&*self.expected_tokens);
expected.sort_by(|a, b| a.to_string().cmp(&b.to_string()));
expected.dedup();
- let expect = tokens_to_string(expected[]);
+ let expect = tokens_to_string(expected.index(&FullRange));
let actual = self.this_token_to_string();
self.fatal(
(if expected.len() != 1 {
(format!("expected {}, found `{}`",
expect,
actual))
- })[]
+ }).index(&FullRange)
)
}
}
/// followed by some token from the set edible + inedible. Recover
/// from anticipated input errors, discarding erroneous characters.
pub fn commit_expr(&mut self, e: &Expr, edible: &[token::Token], inedible: &[token::Token]) {
- debug!("commit_expr {}", e);
+ debug!("commit_expr {:?}", e);
if let ExprPath(..) = e.node {
// might be unit-struct construction; check for recoverableinput error.
let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>();
expected.push_all(inedible);
- self.check_for_erroneous_unit_struct_expecting(expected[]);
+ self.check_for_erroneous_unit_struct_expecting(expected.index(&FullRange));
}
self.expect_one_of(edible, inedible)
}
.as_ref()
.map_or(false, |t| t.is_ident() || t.is_path()) {
let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>();
- expected.push_all(inedible[]);
+ expected.push_all(inedible.index(&FullRange));
self.check_for_erroneous_unit_struct_expecting(
- expected[]);
+ expected.index(&FullRange));
}
self.expect_one_of(edible, inedible)
}
_ => {
let token_str = self.this_token_to_string();
self.fatal((format!("expected ident, found `{}`",
- token_str))[])
+ token_str)).index(&FullRange))
}
}
}
let id_interned_str = token::get_name(kw.to_name());
let token_str = self.this_token_to_string();
self.fatal(format!("expected `{}`, found `{}`",
- id_interned_str, token_str)[])
+ id_interned_str, token_str).index(&FullRange))
}
}
let span = self.span;
self.span_err(span,
format!("expected identifier, found keyword `{}`",
- token_str)[]);
+ token_str).index(&FullRange));
}
}
if self.token.is_reserved_keyword() {
let token_str = self.this_token_to_string();
self.fatal(format!("`{}` is a reserved keyword",
- token_str)[])
+ token_str).index(&FullRange))
}
}
Parser::token_to_string(&token::BinOp(token::And));
self.fatal(format!("expected `{}`, found `{}`",
found_token,
- token_str)[])
+ token_str).index(&FullRange))
}
}
}
Parser::token_to_string(&token::BinOp(token::Or));
self.fatal(format!("expected `{}`, found `{}`",
token_str,
- found_token)[])
+ found_token).index(&FullRange))
}
}
}
let token_str = Parser::token_to_string(&token::Lt);
self.fatal(format!("expected `{}`, found `{}`",
token_str,
- found_token)[])
+ found_token).index(&FullRange))
}
}
let this_token_str = self.this_token_to_string();
self.fatal(format!("expected `{}`, found `{}`",
gt_str,
- this_token_str)[])
+ this_token_str).index(&FullRange))
}
}
}
self.token = next.tok;
self.tokens_consumed += 1u;
self.expected_tokens.clear();
+ // check after each token
+ self.check_unknown_macro_variable();
}
/// Advance the parser by one token and return the bumped token.
let (inner_attrs, body) =
p.parse_inner_attrs_and_block();
let mut attrs = attrs;
- attrs.push_all(inner_attrs[]);
+ attrs.push_all(inner_attrs.index(&FullRange));
ProvidedMethod(P(ast::Method {
attrs: attrs,
id: ast::DUMMY_NODE_ID,
_ => {
let token_str = p.this_token_to_string();
p.fatal((format!("expected `;` or `{{`, found `{}`",
- token_str))[])
+ token_str)).index(&FullRange))
}
}
}
} else {
let this_token_str = self.this_token_to_string();
let msg = format!("expected type, found `{}`", this_token_str);
- self.fatal(msg[]);
+ self.fatal(msg.index(&FullRange));
};
let sp = mk_sp(lo, self.last_span.hi);
token::Str_(s) => {
(true,
- LitStr(token::intern_and_get_ident(parse::str_lit(s.as_str())[]),
+ LitStr(token::intern_and_get_ident(parse::str_lit(s.as_str()).as_slice()),
ast::CookedStr))
}
token::StrRaw(s, n) => {
(true,
LitStr(
token::intern_and_get_ident(
- parse::raw_str_lit(s.as_str())[]),
+ parse::raw_str_lit(s.as_str()).index(&FullRange)),
ast::RawStr(n)))
}
token::Binary(i) =>
};
}
_ => {
- self.fatal(format!("expected a lifetime name")[]);
+ self.fatal(format!("expected a lifetime name").index(&FullRange));
}
}
}
let msg = format!("expected `,` or `>` after lifetime \
name, found `{}`",
this_token_str);
- self.fatal(msg[]);
+ self.fatal(msg.index(&FullRange));
}
}
}
ExprIndex(expr, idx)
}
- pub fn mk_slice(&mut self,
- expr: P<Expr>,
- start: Option<P<Expr>>,
- end: Option<P<Expr>>,
- _mutbl: Mutability)
- -> ast::Expr_ {
- // FIXME: we could give more accurate span info here.
- let (lo, hi) = match (&start, &end) {
- (&Some(ref s), &Some(ref e)) => (s.span.lo, e.span.hi),
- (&Some(ref s), &None) => (s.span.lo, s.span.hi),
- (&None, &Some(ref e)) => (e.span.lo, e.span.hi),
- (&None, &None) => (DUMMY_SP.lo, DUMMY_SP.hi),
- };
- ExprIndex(expr, self.mk_expr(lo, hi, ExprRange(start, end)))
- }
-
pub fn mk_range(&mut self,
start: Option<P<Expr>>,
end: Option<P<Expr>>)
let last_span = self.last_span;
let fstr = n.as_str();
self.span_err(last_span,
- format!("unexpected token: `{}`", n.as_str())[]);
+ format!("unexpected token: `{}`", n.as_str()).index(&FullRange));
if fstr.chars().all(|x| "0123456789.".contains_char(x)) {
let float = match fstr.parse::<f64>() {
Some(f) => f,
self.span_help(last_span,
format!("try parenthesizing the first index; e.g., `(foo.{}){}`",
float.trunc() as uint,
- float.fract().to_string()[1..])[]);
+ float.fract().to_string().index(&(1..))).index(&FullRange));
}
self.abort_if_errors();
}
// expr[...]
- // Could be either an index expression or a slicing expression.
- // Any slicing non-terminal can have a mutable version with `mut`
- // after the opening square bracket.
+ // An index expression.
token::OpenDelim(token::Bracket) => {
+ let bracket_pos = self.span.lo;
self.bump();
- let mutbl = if self.eat_keyword(keywords::Mut) {
- MutMutable
+
+ let mut found_dotdot = false;
+ if self.token == token::DotDot &&
+ self.look_ahead(1, |t| t == &token::CloseDelim(token::Bracket)) {
+ // Using expr[..], which is a mistake, should be expr[]
+ self.bump();
+ self.bump();
+ found_dotdot = true;
+ }
+
+ if found_dotdot || self.eat(&token::CloseDelim(token::Bracket)) {
+ // No expression, expand to a FullRange
+ // FIXME(#20516) It would be better to use a lang item or
+ // something for FullRange.
+ hi = self.last_span.hi;
+ let range = ExprStruct(ident_to_path(mk_sp(lo, hi),
+ token::special_idents::FullRange),
+ vec![],
+ None);
+ let ix = self.mk_expr(bracket_pos, hi, range);
+ let index = self.mk_index(e, ix);
+ e = self.mk_expr(lo, hi, index)
} else {
- MutImmutable
- };
- match self.token {
- // e[]
- token::CloseDelim(token::Bracket) => {
- self.bump();
- hi = self.span.hi;
- let slice = self.mk_slice(e, None, None, mutbl);
- e = self.mk_expr(lo, hi, slice)
- }
- // e[..e]
- token::DotDot => {
- self.bump();
- match self.token {
- // e[..]
- token::CloseDelim(token::Bracket) => {
- self.bump();
- hi = self.span.hi;
- let slice = self.mk_slice(e, None, None, mutbl);
- e = self.mk_expr(lo, hi, slice);
+ let ix = self.parse_expr();
+ hi = self.span.hi;
+ self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket));
+ let index = self.mk_index(e, ix);
+ e = self.mk_expr(lo, hi, index)
+ }
- self.span_err(e.span, "incorrect slicing expression: `[..]`");
- self.span_note(e.span,
- "use `expr[]` to construct a slice of the whole of expr");
- }
- // e[..e]
- _ => {
- hi = self.span.hi;
- let e2 = self.parse_expr();
- self.commit_expr_expecting(&*e2, token::CloseDelim(token::Bracket));
- let slice = self.mk_slice(e, None, Some(e2), mutbl);
- e = self.mk_expr(lo, hi, slice)
- }
- }
- }
- // e[e] | e[e..] | e[e..e]
- _ => {
- let ix = self.parse_expr_res(RESTRICTION_NO_DOTS);
- match self.token {
- // e[e..] | e[e..e]
- token::DotDot => {
- self.bump();
- let e2 = match self.token {
- // e[e..]
- token::CloseDelim(token::Bracket) => {
- self.bump();
- None
- }
- // e[e..e]
- _ => {
- let e2 = self.parse_expr_res(RESTRICTION_NO_DOTS);
- self.commit_expr_expecting(&*e2,
- token::CloseDelim(token::Bracket));
- Some(e2)
- }
- };
- hi = self.span.hi;
- let slice = self.mk_slice(e, Some(ix), e2, mutbl);
- e = self.mk_expr(lo, hi, slice)
- }
- // e[e]
- _ => {
- if mutbl == ast::MutMutable {
- self.span_err(e.span,
- "`mut` keyword is invalid in index expressions");
- }
- hi = self.span.hi;
- self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket));
- let index = self.mk_index(e, ix);
- e = self.mk_expr(lo, hi, index)
- }
- }
- }
+ if found_dotdot {
+ self.span_err(e.span, "incorrect slicing expression: `[..]`");
+ self.span_note(e.span,
+ "use `&expr[]` to construct a slice of the whole of expr");
}
}
return e;
}
+ // Parse unquoted tokens after a `$` in a token tree
+ fn parse_unquoted(&mut self) -> TokenTree {
+ let mut sp = self.span;
+ let (name, namep) = match self.token {
+ token::Dollar => {
+ self.bump();
+
+ if self.token == token::OpenDelim(token::Paren) {
+ let Spanned { node: seq, span: seq_span } = self.parse_seq(
+ &token::OpenDelim(token::Paren),
+ &token::CloseDelim(token::Paren),
+ seq_sep_none(),
+ |p| p.parse_token_tree()
+ );
+ let (sep, repeat) = self.parse_sep_and_kleene_op();
+ let name_num = macro_parser::count_names(seq.as_slice());
+ return TtSequence(mk_sp(sp.lo, seq_span.hi),
+ Rc::new(SequenceRepetition {
+ tts: seq,
+ separator: sep,
+ op: repeat,
+ num_captures: name_num
+ }));
+ } else if self.token.is_keyword_allow_following_colon(keywords::Crate) {
+ self.bump();
+ return TtToken(sp, SpecialVarNt(SpecialMacroVar::CrateMacroVar));
+ } else {
+ sp = mk_sp(sp.lo, self.span.hi);
+ let namep = match self.token { token::Ident(_, p) => p, _ => token::Plain };
+ let name = self.parse_ident();
+ (name, namep)
+ }
+ }
+ token::SubstNt(name, namep) => {
+ self.bump();
+ (name, namep)
+ }
+ _ => unreachable!()
+ };
+ // continue by trying to parse the `:ident` after `$name`
+ if self.token == token::Colon && self.look_ahead(1, |t| t.is_ident() &&
+ !t.is_strict_keyword() &&
+ !t.is_reserved_keyword()) {
+ self.bump();
+ sp = mk_sp(sp.lo, self.span.hi);
+ let kindp = match self.token { token::Ident(_, p) => p, _ => token::Plain };
+ let nt_kind = self.parse_ident();
+ TtToken(sp, MatchNt(name, nt_kind, namep, kindp))
+ } else {
+ TtToken(sp, SubstNt(name, namep))
+ }
+ }
+
+ pub fn check_unknown_macro_variable(&mut self) {
+ if self.quote_depth == 0u {
+ match self.token {
+ token::SubstNt(name, _) =>
+ self.fatal(format!("unknown macro variable `{}`",
+ token::get_ident(name)).index(&FullRange)),
+ _ => {}
+ }
+ }
+ }
+
/// Parse an optional separator followed by a Kleene-style
/// repetition token (+ or *).
pub fn parse_sep_and_kleene_op(&mut self) -> (Option<token::Token>, ast::KleeneOp) {
fn parse_non_delim_tt_tok(p: &mut Parser) -> TokenTree {
maybe_whole!(deref p, NtTT);
match p.token {
- token::CloseDelim(_) => {
- // This is a conservative error: only report the last unclosed delimiter. The
- // previous unclosed delimiters could actually be closed! The parser just hasn't
- // gotten to them yet.
- match p.open_braces.last() {
- None => {}
- Some(&sp) => p.span_note(sp, "unclosed delimiter"),
- };
- let token_str = p.this_token_to_string();
- p.fatal(format!("incorrect close delimiter: `{}`",
- token_str)[])
- },
- /* we ought to allow different depths of unquotation */
- token::Dollar if p.quote_depth > 0u => {
- p.bump();
- let sp = p.span;
-
- if p.token == token::OpenDelim(token::Paren) {
- let seq = p.parse_seq(
- &token::OpenDelim(token::Paren),
- &token::CloseDelim(token::Paren),
- seq_sep_none(),
- |p| p.parse_token_tree()
- );
- let (sep, repeat) = p.parse_sep_and_kleene_op();
- let seq = match seq {
- Spanned { node, .. } => node,
+ token::CloseDelim(_) => {
+ // This is a conservative error: only report the last unclosed delimiter. The
+ // previous unclosed delimiters could actually be closed! The parser just hasn't
+ // gotten to them yet.
+ match p.open_braces.last() {
+ None => {}
+ Some(&sp) => p.span_note(sp, "unclosed delimiter"),
};
- let name_num = macro_parser::count_names(seq[]);
- TtSequence(mk_sp(sp.lo, p.span.hi),
- Rc::new(SequenceRepetition {
- tts: seq,
- separator: sep,
- op: repeat,
- num_captures: name_num
- }))
- } else if p.token.is_keyword_allow_following_colon(keywords::Crate) {
- p.bump();
- TtToken(sp, SpecialVarNt(SpecialMacroVar::CrateMacroVar))
- } else {
- // A nonterminal that matches or not
- let namep = match p.token { token::Ident(_, p) => p, _ => token::Plain };
- let name = p.parse_ident();
- if p.token == token::Colon && p.look_ahead(1, |t| t.is_ident()) {
- p.bump();
- let kindp = match p.token { token::Ident(_, p) => p, _ => token::Plain };
- let nt_kind = p.parse_ident();
- let m = TtToken(sp, MatchNt(name, nt_kind, namep, kindp));
- m
- } else {
- TtToken(sp, SubstNt(name, namep))
- }
+ let token_str = p.this_token_to_string();
+ p.fatal(format!("incorrect close delimiter: `{}`",
+ token_str).index(&FullRange))
+ },
+ /* we ought to allow different depths of unquotation */
+ token::Dollar | token::SubstNt(..) if p.quote_depth > 0u => {
+ p.parse_unquoted()
+ }
+ _ => {
+ TtToken(p.span, p.bump_and_get())
}
- }
- _ => {
- TtToken(p.span, p.bump_and_get())
- }
}
}
let this_token_to_string = self.this_token_to_string();
self.span_err(span,
format!("expected expression, found `{}`",
- this_token_to_string)[]);
+ this_token_to_string).index(&FullRange));
let box_span = mk_sp(lo, self.last_span.hi);
self.span_help(box_span,
"perhaps you meant `box() (foo)` instead?");
if self.token != token::CloseDelim(token::Brace) {
let token_str = self.this_token_to_string();
self.fatal(format!("expected `{}`, found `{}`", "}",
- token_str)[])
+ token_str).index(&FullRange))
}
etc = true;
break;
BindByRef(..) | BindByValue(MutMutable) => {
let token_str = self.this_token_to_string();
self.fatal(format!("unexpected `{}`",
- token_str)[])
+ token_str).index(&FullRange))
}
_ => {}
}
let span = self.span;
let tok_str = self.this_token_to_string();
self.span_fatal(span,
- format!("expected identifier, found `{}`", tok_str)[]);
+ format!("expected identifier, found `{}`", tok_str).index(&FullRange));
}
let ident = self.parse_ident();
let last_span = self.last_span;
let lo = self.span.lo;
if self.token.is_keyword(keywords::Let) {
- check_expected_item(self, item_attrs[]);
+ check_expected_item(self, item_attrs.index(&FullRange));
self.expect_keyword(keywords::Let);
let decl = self.parse_let();
P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID)))
&& self.look_ahead(1, |t| *t == token::Not) {
// it's a macro invocation:
- check_expected_item(self, item_attrs[]);
+ check_expected_item(self, item_attrs.index(&FullRange));
// Potential trouble: if we allow macros with paths instead of
// idents, we'd need to look ahead past the whole path here...
let tok_str = self.this_token_to_string();
self.fatal(format!("expected {}`(` or `{{`, found `{}`",
ident_str,
- tok_str)[])
+ tok_str).index(&FullRange))
},
};
}
} else {
let found_attrs = !item_attrs.is_empty();
- let item_err = Parser::expected_item_err(item_attrs[]);
+ let item_err = Parser::expected_item_err(item_attrs.index(&FullRange));
match self.parse_item_or_view_item(item_attrs, false) {
IoviItem(i) => {
let hi = i.span.hi;
let sp = self.span;
let tok = self.this_token_to_string();
self.span_fatal_help(sp,
- format!("expected `{{`, found `{}`", tok)[],
+ format!("expected `{{`, found `{}`", tok).index(&FullRange),
"place this code inside a block");
}
while self.token != token::CloseDelim(token::Brace) {
// parsing items even when they're not allowed lets us give
// better error messages and recover more gracefully.
- attributes_box.push_all(self.parse_outer_attributes()[]);
+ attributes_box.push_all(self.parse_outer_attributes().index(&FullRange));
match self.token {
token::Semi => {
if !attributes_box.is_empty() {
let last_span = self.last_span;
self.span_err(last_span,
- Parser::expected_item_err(attributes_box[]));
+ Parser::expected_item_err(attributes_box.index(&FullRange)));
attributes_box = Vec::new();
}
self.bump(); // empty
if !attributes_box.is_empty() {
let last_span = self.last_span;
self.span_err(last_span,
- Parser::expected_item_err(attributes_box[]));
+ Parser::expected_item_err(attributes_box.index(&FullRange)));
}
let hi = self.span.hi;
_ => {
let token_str = self.this_token_to_string();
self.fatal(format!("expected `self`, found `{}`",
- token_str)[])
+ token_str).index(&FullRange))
}
}
}
_ => {
let token_str = self.this_token_to_string();
self.fatal(format!("expected `,` or `)`, found `{}`",
- token_str)[])
+ token_str).index(&FullRange))
}
}
}
let (inner_attrs, body) = self.parse_inner_attrs_and_block();
let body_span = body.span;
let mut new_attrs = attrs;
- new_attrs.push_all(inner_attrs[]);
+ new_attrs.push_all(inner_attrs.index(&FullRange));
(ast::MethDecl(ident,
generics,
abi,
if fields.len() == 0 {
self.fatal(format!("unit-like struct definition should be \
written as `struct {};`",
- token::get_ident(class_name.clone()))[]);
+ token::get_ident(class_name.clone())).index(&FullRange));
}
self.bump();
let token_str = self.this_token_to_string();
self.fatal(format!("expected `where`, or `{}` after struct \
name, found `{}`", "{",
- token_str)[]);
+ token_str).index(&FullRange));
}
fields
if fields.len() == 0 {
self.fatal(format!("unit-like struct definition should be \
written as `struct {};`",
- token::get_ident(class_name.clone()))[]);
+ token::get_ident(class_name.clone())).index(&FullRange));
}
self.parse_where_clause(generics);
} else {
let token_str = self.this_token_to_string();
self.fatal(format!("expected `where`, `{}`, `(`, or `;` after struct \
- name, found `{}`", "{", token_str)[]);
+ name, found `{}`", "{", token_str).index(&FullRange));
}
}
let token_str = self.this_token_to_string();
self.span_fatal_help(span,
format!("expected `,`, or `}}`, found `{}`",
- token_str)[],
+ token_str).index(&FullRange),
"struct fields should be separated by commas")
}
}
let mut attrs = self.parse_outer_attributes();
if first {
let mut tmp = attrs_remaining.clone();
- tmp.push_all(attrs[]);
+ tmp.push_all(attrs.index(&FullRange));
attrs = tmp;
first = false;
}
- debug!("parse_mod_items: parse_item_or_view_item(attrs={})",
+ debug!("parse_mod_items: parse_item_or_view_item(attrs={:?})",
attrs);
match self.parse_item_or_view_item(attrs,
true /* macros allowed */) {
_ => {
let token_str = self.this_token_to_string();
self.fatal(format!("expected item, found `{}`",
- token_str)[])
+ token_str).index(&FullRange))
}
}
}
// We parsed attributes for the first item but didn't find it
let last_span = self.last_span;
self.span_err(last_span,
- Parser::expected_item_err(attrs_remaining[]));
+ Parser::expected_item_err(attrs_remaining.index(&FullRange)));
}
ast::Mod {
-> (ast::Item_, Vec<ast::Attribute> ) {
let mut prefix = Path::new(self.sess.span_diagnostic.cm.span_to_filename(self.span));
prefix.pop();
- let mod_path = Path::new(".").join_many(self.mod_path_stack[]);
+ let mod_path = Path::new(".").join_many(self.mod_path_stack.index(&FullRange));
let dir_path = prefix.join(&mod_path);
let mod_string = token::get_ident(id);
let (file_path, owns_directory) = match ::attr::first_attr_value_str_by_name(
let mod_name = mod_string.get().to_string();
let default_path_str = format!("{}.rs", mod_name);
let secondary_path_str = format!("{}/mod.rs", mod_name);
- let default_path = dir_path.join(default_path_str[]);
- let secondary_path = dir_path.join(secondary_path_str[]);
+ let default_path = dir_path.join(default_path_str.index(&FullRange));
+ let secondary_path = dir_path.join(secondary_path_str.index(&FullRange));
let default_exists = default_path.exists();
let secondary_exists = secondary_path.exists();
format!("maybe move this module `{0}` \
to its own directory via \
`{0}/mod.rs`",
- this_module)[]);
+ this_module).index(&FullRange));
if default_exists || secondary_exists {
self.span_note(id_sp,
format!("... or maybe `use` the module \
`{}` instead of possibly \
redeclaring it",
- mod_name)[]);
+ mod_name).index(&FullRange));
}
self.abort_if_errors();
}
(false, false) => {
self.span_fatal_help(id_sp,
format!("file not found for module `{}`",
- mod_name)[],
+ mod_name).index(&FullRange),
format!("name the file either {} or {} inside \
- the directory {}",
+ the directory {:?}",
default_path_str,
secondary_path_str,
- dir_path.display())[]);
+ dir_path.display()).index(&FullRange));
}
(true, true) => {
self.span_fatal_help(
and {}",
mod_name,
default_path_str,
- secondary_path_str)[],
+ secondary_path_str).index(&FullRange),
"delete or rename one of them to remove the ambiguity");
}
}
let mut err = String::from_str("circular modules: ");
let len = included_mod_stack.len();
for p in included_mod_stack.slice(i, len).iter() {
- err.push_str(p.display().as_cow()[]);
+ err.push_str(p.display().as_cow().index(&FullRange));
err.push_str(" -> ");
}
- err.push_str(path.display().as_cow()[]);
- self.span_fatal(id_sp, err[]);
+ err.push_str(path.display().as_cow().index(&FullRange));
+ self.span_fatal(id_sp, err.index(&FullRange));
}
None => ()
}
if !attrs_remaining.is_empty() {
let last_span = self.last_span;
self.span_err(last_span,
- Parser::expected_item_err(attrs_remaining[]));
+ Parser::expected_item_err(attrs_remaining.index(&FullRange)));
}
assert!(self.token == token::CloseDelim(token::Brace));
ast::ForeignMod {
self.span_help(span,
format!("perhaps you meant to enclose the crate name `{}` in \
a string?",
- the_ident.as_str())[]);
+ the_ident.as_str()).index(&FullRange));
None
} else {
None
self.span_fatal(span,
format!("expected extern crate name but \
found `{}`",
- token_str)[]);
+ token_str).index(&FullRange));
}
};
self.span_err(start_span,
format!("unit-like struct variant should be written \
without braces, as `{},`",
- token::get_ident(ident))[]);
+ token::get_ident(ident)).index(&FullRange));
}
kind = StructVariantKind(struct_def);
} else if self.check(&token::OpenDelim(token::Paren)) {
format!("illegal ABI: expected one of [{}], \
found `{}`",
abi::all_names().connect(", "),
- the_string)[]);
+ the_string).index(&FullRange));
None
}
}
format!("`extern mod` is obsolete, use \
`extern crate` instead \
to refer to external \
- crates.")[])
+ crates.").index(&FullRange))
}
return self.parse_item_extern_crate(lo, visibility, attrs);
}
let token_str = self.this_token_to_string();
self.span_fatal(span,
format!("expected `{}` or `fn`, found `{}`", "{",
- token_str)[]);
+ token_str).index(&FullRange));
}
if self.eat_keyword(keywords::Virtual) {
if self.eat_keyword(keywords::Mod) {
// MODULE ITEM
let (ident, item_, extra_attrs) =
- self.parse_item_mod(attrs[]);
+ self.parse_item_mod(attrs.index(&FullRange));
let last_span = self.last_span;
let item = self.mk_item(lo,
last_span.hi,
macros_allowed: bool)
-> ParsedItemsAndViewItems {
let mut attrs = first_item_attrs;
- attrs.push_all(self.parse_outer_attributes()[]);
+ attrs.push_all(self.parse_outer_attributes().index(&FullRange));
// First, parse view items.
let mut view_items : Vec<ast::ViewItem> = Vec::new();
let mut items = Vec::new();
macros_allowed: bool)
-> ParsedItemsAndViewItems {
let mut attrs = first_item_attrs;
- attrs.push_all(self.parse_outer_attributes()[]);
+ attrs.push_all(self.parse_outer_attributes().index(&FullRange));
let mut foreign_items = Vec::new();
loop {
match self.parse_foreign_item(attrs, macros_allowed) {
}
}
+
// Get the first "argument"
macro_rules! first {
( $first:expr, $( $remainder:expr, )* ) => ( $first )
$(init_vec.push($si_str);)*
$(init_vec.push($sk_str);)*
$(init_vec.push($rk_str);)*
- interner::StrInterner::prefill(init_vec[])
+ interner::StrInterner::prefill(init_vec.index(&FullRange))
}
}}
(9, unnamed_field, "<unnamed_field>");
(10, type_self, "Self");
(11, prelude_import, "prelude_import");
+ (12, FullRange, "FullRange");
}
pub mod keywords {
// These ones are variants of the Keyword enum
'strict:
- (12, As, "as");
- (13, Break, "break");
- (14, Crate, "crate");
- (15, Else, "else");
- (16, Enum, "enum");
- (17, Extern, "extern");
- (18, False, "false");
- (19, Fn, "fn");
- (20, For, "for");
- (21, If, "if");
- (22, Impl, "impl");
- (23, In, "in");
- (24, Let, "let");
- (25, Loop, "loop");
- (26, Match, "match");
- (27, Mod, "mod");
- (28, Move, "move");
- (29, Mut, "mut");
- (30, Pub, "pub");
- (31, Ref, "ref");
- (32, Return, "return");
+ (13, As, "as");
+ (14, Break, "break");
+ (15, Crate, "crate");
+ (16, Else, "else");
+ (17, Enum, "enum");
+ (18, Extern, "extern");
+ (19, False, "false");
+ (20, Fn, "fn");
+ (21, For, "for");
+ (22, If, "if");
+ (23, Impl, "impl");
+ (24, In, "in");
+ (25, Let, "let");
+ (26, Loop, "loop");
+ (27, Match, "match");
+ (28, Mod, "mod");
+ (29, Move, "move");
+ (30, Mut, "mut");
+ (31, Pub, "pub");
+ (32, Ref, "ref");
+ (33, Return, "return");
// Static and Self are also special idents (prefill de-dupes)
(super::STATIC_KEYWORD_NAME_NUM, Static, "static");
(super::SELF_KEYWORD_NAME_NUM, Self, "self");
- (33, Struct, "struct");
+ (34, Struct, "struct");
(super::SUPER_KEYWORD_NAME_NUM, Super, "super");
- (34, True, "true");
- (35, Trait, "trait");
- (36, Type, "type");
- (37, Unsafe, "unsafe");
- (38, Use, "use");
- (39, Virtual, "virtual");
- (40, While, "while");
- (41, Continue, "continue");
- (42, Proc, "proc");
- (43, Box, "box");
- (44, Const, "const");
- (45, Where, "where");
-
+ (35, True, "true");
+ (36, Trait, "trait");
+ (37, Type, "type");
+ (38, Unsafe, "unsafe");
+ (39, Use, "use");
+ (40, Virtual, "virtual");
+ (41, While, "while");
+ (42, Continue, "continue");
+ (43, Proc, "proc");
+ (44, Box, "box");
+ (45, Const, "const");
+ (46, Where, "where");
'reserved:
- (46, Alignof, "alignof");
- (47, Be, "be");
- (48, Offsetof, "offsetof");
- (49, Priv, "priv");
- (50, Pure, "pure");
- (51, Sizeof, "sizeof");
- (52, Typeof, "typeof");
- (53, Unsized, "unsized");
- (54, Yield, "yield");
- (55, Do, "do");
- (56, Abstract, "abstract");
- (57, Final, "final");
- (58, Override, "override");
- (59, Macro, "macro");
+ (47, Alignof, "alignof");
+ (48, Be, "be");
+ (49, Offsetof, "offsetof");
+ (50, Priv, "priv");
+ (51, Pure, "pure");
+ (52, Sizeof, "sizeof");
+ (53, Typeof, "typeof");
+ (54, Unsized, "unsized");
+ (55, Yield, "yield");
+ (56, Do, "do");
+ (57, Abstract, "abstract");
+ (58, Final, "final");
+ (59, Override, "override");
+ (60, Macro, "macro");
}
}
#[inline]
pub fn get<'a>(&'a self) -> &'a str {
- self.string[]
+ self.string.index(&FullRange)
}
}
impl fmt::Show for InternedString {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", self.string[])
+ fmt::String::fmt(self, f)
+ }
+}
+
+impl fmt::String for InternedString {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.string.index(&FullRange))
}
}
impl<'a> PartialEq<&'a str> for InternedString {
#[inline(always)]
fn eq(&self, other: & &'a str) -> bool {
- PartialEq::eq(self.string[], *other)
+ PartialEq::eq(self.string.index(&FullRange), *other)
}
#[inline(always)]
fn ne(&self, other: & &'a str) -> bool {
- PartialEq::ne(self.string[], *other)
+ PartialEq::ne(self.string.index(&FullRange), *other)
}
}
impl<'a> PartialEq<InternedString > for &'a str {
#[inline(always)]
fn eq(&self, other: &InternedString) -> bool {
- PartialEq::eq(*self, other.string[])
+ PartialEq::eq(*self, other.string.index(&FullRange))
}
#[inline(always)]
fn ne(&self, other: &InternedString) -> bool {
- PartialEq::ne(*self, other.string[])
+ PartialEq::ne(*self, other.string.index(&FullRange))
}
}
-#[cfg(stage0)]
-impl<D:Decoder<E>, E> Decodable<D, E> for InternedString {
- fn decode(d: &mut D) -> Result<InternedString, E> {
- Ok(get_name(get_ident_interner().intern(
- try!(d.read_str())[])))
- }
-}
-
-#[cfg(not(stage0))]
impl Decodable for InternedString {
fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> {
- Ok(get_name(get_ident_interner().intern(
- try!(d.read_str())[])))
- }
-}
-
-#[cfg(stage0)]
-impl<S:Encoder<E>, E> Encodable<S, E> for InternedString {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_str(self.string[])
+ Ok(get_name(get_ident_interner().intern(try!(d.read_str()).index(&FullRange))))
}
}
-#[cfg(not(stage0))]
impl Encodable for InternedString {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_str(self.string[])
+ s.emit_str(self.string.index(&FullRange))
}
}
}
s.push_str(format!("{}={}",
szs[i],
- tok_str(toks[i].clone()))[]);
+ tok_str(toks[i].clone())).index(&FullRange));
i += 1u;
i %= n;
}
assert_eq!(l, len);
// assert!(l <= space);
self.space -= len;
- self.print_str(s[])
+ self.print_str(s.index(&FullRange))
}
Eof => {
// Eof should never get here.
out,
ann,
is_expanded);
- try!(s.print_mod(&krate.module, krate.attrs[]));
+ try!(s.print_mod(&krate.module, krate.attrs.index(&FullRange)));
try!(s.print_remaining_comments());
eof(&mut s.s)
}
pub fn synth_comment(&mut self, text: String) -> IoResult<()> {
try!(word(&mut self.s, "/*"));
try!(space(&mut self.s));
- try!(word(&mut self.s, text[]));
+ try!(word(&mut self.s, text.index(&FullRange)));
try!(space(&mut self.s));
word(&mut self.s, "*/")
}
}
ast::TyTup(ref elts) => {
try!(self.popen());
- try!(self.commasep(Inconsistent, elts[],
+ try!(self.commasep(Inconsistent, elts.index(&FullRange),
|s, ty| s.print_type(&**ty)));
if elts.len() == 1 {
try!(word(&mut self.s, ","));
}
ast::TyObjectSum(ref ty, ref bounds) => {
try!(self.print_type(&**ty));
- try!(self.print_bounds("+", bounds[]));
+ try!(self.print_bounds("+", bounds.index(&FullRange)));
}
ast::TyPolyTraitRef(ref bounds) => {
- try!(self.print_bounds("", bounds[]));
+ try!(self.print_bounds("", bounds.index(&FullRange)));
}
ast::TyQPath(ref qpath) => {
try!(word(&mut self.s, "<"));
item: &ast::ForeignItem) -> IoResult<()> {
try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(item.span.lo));
- try!(self.print_outer_attributes(item.attrs[]));
+ try!(self.print_outer_attributes(item.attrs.index(&FullRange)));
match item.node {
ast::ForeignItemFn(ref decl, ref generics) => {
try!(self.print_fn(&**decl, None, abi::Rust, item.ident, generics,
}
ast::ForeignItemStatic(ref t, m) => {
try!(self.head(visibility_qualified(item.vis,
- "static")[]));
+ "static").index(&FullRange)));
if m {
try!(self.word_space("mut"));
}
fn print_associated_type(&mut self, typedef: &ast::AssociatedType)
-> IoResult<()>
{
- try!(self.print_outer_attributes(typedef.attrs[]));
+ try!(self.print_outer_attributes(typedef.attrs.index(&FullRange)));
try!(self.word_space("type"));
try!(self.print_ty_param(&typedef.ty_param));
word(&mut self.s, ";")
pub fn print_item(&mut self, item: &ast::Item) -> IoResult<()> {
try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(item.span.lo));
- try!(self.print_outer_attributes(item.attrs[]));
+ try!(self.print_outer_attributes(item.attrs.index(&FullRange)));
try!(self.ann.pre(self, NodeItem(item)));
match item.node {
ast::ItemStatic(ref ty, m, ref expr) => {
try!(self.head(visibility_qualified(item.vis,
- "static")[]));
+ "static").index(&FullRange)));
if m == ast::MutMutable {
try!(self.word_space("mut"));
}
}
ast::ItemConst(ref ty, ref expr) => {
try!(self.head(visibility_qualified(item.vis,
- "const")[]));
+ "const").index(&FullRange)));
try!(self.print_ident(item.ident));
try!(self.word_space(":"));
try!(self.print_type(&**ty));
item.vis
));
try!(word(&mut self.s, " "));
- try!(self.print_block_with_attrs(&**body, item.attrs[]));
+ try!(self.print_block_with_attrs(&**body, item.attrs.index(&FullRange)));
}
ast::ItemMod(ref _mod) => {
try!(self.head(visibility_qualified(item.vis,
- "mod")[]));
+ "mod").index(&FullRange)));
try!(self.print_ident(item.ident));
try!(self.nbsp());
try!(self.bopen());
- try!(self.print_mod(_mod, item.attrs[]));
+ try!(self.print_mod(_mod, item.attrs.index(&FullRange)));
try!(self.bclose(item.span));
}
ast::ItemForeignMod(ref nmod) => {
try!(self.head("extern"));
- try!(self.word_nbsp(nmod.abi.to_string()[]));
+ try!(self.word_nbsp(nmod.abi.to_string().index(&FullRange)));
try!(self.bopen());
- try!(self.print_foreign_mod(nmod, item.attrs[]));
+ try!(self.print_foreign_mod(nmod, item.attrs.index(&FullRange)));
try!(self.bclose(item.span));
}
ast::ItemTy(ref ty, ref params) => {
try!(self.ibox(indent_unit));
try!(self.ibox(0u));
try!(self.word_nbsp(visibility_qualified(item.vis,
- "type")[]));
+ "type").index(&FullRange)));
try!(self.print_ident(item.ident));
try!(self.print_generics(params));
try!(self.end()); // end the inner ibox
));
}
ast::ItemStruct(ref struct_def, ref generics) => {
- try!(self.head(visibility_qualified(item.vis,"struct")[]));
+ try!(self.head(visibility_qualified(item.vis,"struct").index(&FullRange)));
try!(self.print_struct(&**struct_def, generics, item.ident, item.span));
}
try!(space(&mut self.s));
try!(self.bopen());
- try!(self.print_inner_attributes(item.attrs[]));
+ try!(self.print_inner_attributes(item.attrs.index(&FullRange)));
for impl_item in impl_items.iter() {
match *impl_item {
ast::MethodImplItem(ref meth) => {
real_bounds.push(b);
}
}
- try!(self.print_bounds(":", real_bounds[]));
+ try!(self.print_bounds(":", real_bounds.index(&FullRange)));
try!(self.print_where_clause(generics));
try!(word(&mut self.s, " "));
try!(self.bopen());
try!(self.print_ident(item.ident));
try!(self.cbox(indent_unit));
try!(self.popen());
- try!(self.print_tts(tts[]));
+ try!(self.print_tts(tts.index(&FullRange)));
try!(self.pclose());
try!(word(&mut self.s, ";"));
try!(self.end());
generics: &ast::Generics, ident: ast::Ident,
span: codemap::Span,
visibility: ast::Visibility) -> IoResult<()> {
- try!(self.head(visibility_qualified(visibility, "enum")[]));
+ try!(self.head(visibility_qualified(visibility, "enum").index(&FullRange)));
try!(self.print_ident(ident));
try!(self.print_generics(generics));
try!(self.print_where_clause(generics));
try!(space(&mut self.s));
- self.print_variants(enum_definition.variants[], span)
+ self.print_variants(enum_definition.variants.index(&FullRange), span)
}
pub fn print_variants(&mut self,
for v in variants.iter() {
try!(self.space_if_not_bol());
try!(self.maybe_print_comment(v.span.lo));
- try!(self.print_outer_attributes(v.node.attrs[]));
+ try!(self.print_outer_attributes(v.node.attrs.index(&FullRange)));
try!(self.ibox(indent_unit));
try!(self.print_variant(&**v));
try!(word(&mut self.s, ","));
if !struct_def.fields.is_empty() {
try!(self.popen());
try!(self.commasep(
- Inconsistent, struct_def.fields[],
+ Inconsistent, struct_def.fields.index(&FullRange),
|s, field| {
match field.node.kind {
ast::NamedField(..) => panic!("unexpected named field"),
ast::NamedField(ident, visibility) => {
try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(field.span.lo));
- try!(self.print_outer_attributes(field.node.attrs[]));
+ try!(self.print_outer_attributes(field.node.attrs.index(&FullRange)));
try!(self.print_visibility(visibility));
try!(self.print_ident(ident));
try!(self.word_nbsp(":"));
pub fn print_tt(&mut self, tt: &ast::TokenTree) -> IoResult<()> {
match *tt {
ast::TtToken(_, ref tk) => {
- try!(word(&mut self.s, token_to_string(tk)[]));
+ try!(word(&mut self.s, token_to_string(tk).index(&FullRange)));
match *tk {
parse::token::DocComment(..) => {
hardbreak(&mut self.s)
}
}
ast::TtDelimited(_, ref delimed) => {
- try!(word(&mut self.s, token_to_string(&delimed.open_token())[]));
+ try!(word(&mut self.s, token_to_string(&delimed.open_token()).index(&FullRange)));
try!(space(&mut self.s));
- try!(self.print_tts(delimed.tts[]));
+ try!(self.print_tts(delimed.tts.index(&FullRange)));
try!(space(&mut self.s));
- word(&mut self.s, token_to_string(&delimed.close_token())[])
+ word(&mut self.s, token_to_string(&delimed.close_token()).index(&FullRange))
},
ast::TtSequence(_, ref seq) => {
try!(word(&mut self.s, "$("));
try!(word(&mut self.s, ")"));
match seq.separator {
Some(ref tk) => {
- try!(word(&mut self.s, token_to_string(tk)[]));
+ try!(word(&mut self.s, token_to_string(tk).index(&FullRange)));
}
None => {},
}
if !args.is_empty() {
try!(self.popen());
try!(self.commasep(Consistent,
- args[],
+ args.index(&FullRange),
|s, arg| s.print_type(&*arg.ty)));
try!(self.pclose());
}
pub fn print_ty_method(&mut self, m: &ast::TypeMethod) -> IoResult<()> {
try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(m.span.lo));
- try!(self.print_outer_attributes(m.attrs[]));
+ try!(self.print_outer_attributes(m.attrs.index(&FullRange)));
try!(self.print_ty_fn(None,
None,
m.unsafety,
pub fn print_method(&mut self, meth: &ast::Method) -> IoResult<()> {
try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(meth.span.lo));
- try!(self.print_outer_attributes(meth.attrs[]));
+ try!(self.print_outer_attributes(meth.attrs.index(&FullRange)));
match meth.node {
ast::MethDecl(ident,
ref generics,
Some(&explicit_self.node),
vis));
try!(word(&mut self.s, " "));
- self.print_block_with_attrs(&**body, meth.attrs[])
+ self.print_block_with_attrs(&**body, meth.attrs.index(&FullRange))
},
ast::MethMac(codemap::Spanned { node: ast::MacInvocTT(ref pth, ref tts, _),
..}) => {
try!(word(&mut self.s, "! "));
try!(self.cbox(indent_unit));
try!(self.popen());
- try!(self.print_tts(tts[]));
+ try!(self.print_tts(tts.index(&FullRange)));
try!(self.pclose());
try!(word(&mut self.s, ";"));
self.end()
ast::ExprVec(ref exprs) => {
try!(self.ibox(indent_unit));
try!(word(&mut self.s, "["));
- try!(self.commasep_exprs(Inconsistent, exprs[]));
+ try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange)));
try!(word(&mut self.s, "]"));
try!(self.end());
}
ast::ExprStruct(ref path, ref fields, ref wth) => {
try!(self.print_path(path, true));
- try!(word(&mut self.s, "{"));
- try!(self.commasep_cmnt(
- Consistent,
- fields[],
- |s, field| {
- try!(s.ibox(indent_unit));
- try!(s.print_ident(field.ident.node));
- try!(s.word_space(":"));
- try!(s.print_expr(&*field.expr));
- s.end()
- },
- |f| f.span));
- match *wth {
- Some(ref expr) => {
- try!(self.ibox(indent_unit));
- if !fields.is_empty() {
- try!(word(&mut self.s, ","));
- try!(space(&mut self.s));
+ if !(fields.is_empty() && wth.is_none()) {
+ try!(word(&mut self.s, "{"));
+ try!(self.commasep_cmnt(
+ Consistent,
+ fields.index(&FullRange),
+ |s, field| {
+ try!(s.ibox(indent_unit));
+ try!(s.print_ident(field.ident.node));
+ try!(s.word_space(":"));
+ try!(s.print_expr(&*field.expr));
+ s.end()
+ },
+ |f| f.span));
+ match *wth {
+ Some(ref expr) => {
+ try!(self.ibox(indent_unit));
+ if !fields.is_empty() {
+ try!(word(&mut self.s, ","));
+ try!(space(&mut self.s));
+ }
+ try!(word(&mut self.s, ".."));
+ try!(self.print_expr(&**expr));
+ try!(self.end());
}
- try!(word(&mut self.s, ".."));
- try!(self.print_expr(&**expr));
- try!(self.end());
+ _ => try!(word(&mut self.s, ",")),
}
- _ => try!(word(&mut self.s, ","))
+ try!(word(&mut self.s, "}"));
}
- try!(word(&mut self.s, "}"));
}
ast::ExprTup(ref exprs) => {
try!(self.popen());
- try!(self.commasep_exprs(Inconsistent, exprs[]));
+ try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange)));
if exprs.len() == 1 {
try!(word(&mut self.s, ","));
}
}
ast::ExprCall(ref func, ref args) => {
try!(self.print_expr_maybe_paren(&**func));
- try!(self.print_call_post(args[]));
+ try!(self.print_call_post(args.index(&FullRange)));
}
ast::ExprMethodCall(ident, ref tys, ref args) => {
let base_args = args.slice_from(1);
try!(self.print_ident(ident.node));
if tys.len() > 0u {
try!(word(&mut self.s, "::<"));
- try!(self.commasep(Inconsistent, tys[],
+ try!(self.commasep(Inconsistent, tys.index(&FullRange),
|s, ty| s.print_type(&**ty)));
try!(word(&mut self.s, ">"));
}
try!(self.print_string(a.asm.get(), a.asm_str_style));
try!(self.word_space(":"));
- try!(self.commasep(Inconsistent, a.outputs[],
+ try!(self.commasep(Inconsistent, a.outputs.index(&FullRange),
|s, &(ref co, ref o, is_rw)| {
match co.get().slice_shift_char() {
Some(('=', operand)) if is_rw => {
- try!(s.print_string(format!("+{}", operand)[],
+ try!(s.print_string(format!("+{}", operand).index(&FullRange),
ast::CookedStr))
}
_ => try!(s.print_string(co.get(), ast::CookedStr))
try!(space(&mut self.s));
try!(self.word_space(":"));
- try!(self.commasep(Inconsistent, a.inputs[],
+ try!(self.commasep(Inconsistent, a.inputs.index(&FullRange),
|s, &(ref co, ref o)| {
try!(s.print_string(co.get(), ast::CookedStr));
try!(s.popen());
try!(space(&mut self.s));
try!(self.word_space(":"));
- try!(self.commasep(Inconsistent, a.clobbers[],
+ try!(self.commasep(Inconsistent, a.clobbers.index(&FullRange),
|s, co| {
try!(s.print_string(co.get(), ast::CookedStr));
Ok(())
pub fn print_ident(&mut self, ident: ast::Ident) -> IoResult<()> {
if self.encode_idents_with_hygiene {
let encoded = ident.encode_with_hygiene();
- try!(word(&mut self.s, encoded[]))
+ try!(word(&mut self.s, encoded.index(&FullRange)))
} else {
try!(word(&mut self.s, token::get_ident(ident).get()))
}
}
pub fn print_uint(&mut self, i: uint) -> IoResult<()> {
- word(&mut self.s, i.to_string()[])
+ word(&mut self.s, i.to_string().index(&FullRange))
}
pub fn print_name(&mut self, name: ast::Name) -> IoResult<()> {
}
try!(self.commasep(
Inconsistent,
- data.types[],
+ data.types.index(&FullRange),
|s, ty| s.print_type(&**ty)));
comma = true;
}
try!(word(&mut self.s, "("));
try!(self.commasep(
Inconsistent,
- data.inputs[],
+ data.inputs.index(&FullRange),
|s, ty| s.print_type(&**ty)));
try!(word(&mut self.s, ")"));
Some(ref args) => {
if !args.is_empty() {
try!(self.popen());
- try!(self.commasep(Inconsistent, args[],
+ try!(self.commasep(Inconsistent, args.index(&FullRange),
|s, p| s.print_pat(&**p)));
try!(self.pclose());
}
try!(self.nbsp());
try!(self.word_space("{"));
try!(self.commasep_cmnt(
- Consistent, fields[],
+ Consistent, fields.index(&FullRange),
|s, f| {
try!(s.cbox(indent_unit));
if !f.node.is_shorthand {
ast::PatTup(ref elts) => {
try!(self.popen());
try!(self.commasep(Inconsistent,
- elts[],
+ elts.index(&FullRange),
|s, p| s.print_pat(&**p)));
if elts.len() == 1 {
try!(word(&mut self.s, ","));
ast::PatVec(ref before, ref slice, ref after) => {
try!(word(&mut self.s, "["));
try!(self.commasep(Inconsistent,
- before[],
+ before.index(&FullRange),
|s, p| s.print_pat(&**p)));
for p in slice.iter() {
if !before.is_empty() { try!(self.word_space(",")); }
if !after.is_empty() { try!(self.word_space(",")); }
}
try!(self.commasep(Inconsistent,
- after[],
+ after.index(&FullRange),
|s, p| s.print_pat(&**p)));
try!(word(&mut self.s, "]"));
}
}
try!(self.cbox(indent_unit));
try!(self.ibox(0u));
- try!(self.print_outer_attributes(arm.attrs[]));
+ try!(self.print_outer_attributes(arm.attrs.index(&FullRange)));
let mut first = true;
for p in arm.pats.iter() {
if first {
// HACK(eddyb) ignore the separately printed self argument.
let args = if first {
- decl.inputs[]
+ decl.inputs.index(&FullRange)
} else {
decl.inputs.slice_from(1)
};
ints.push(i);
}
- try!(self.commasep(Inconsistent, ints[], |s, &idx| {
+ try!(self.commasep(Inconsistent, ints.index(&FullRange), |s, &idx| {
if idx < generics.lifetimes.len() {
let lifetime = &generics.lifetimes[idx];
s.print_lifetime_def(lifetime)
pub fn print_ty_param(&mut self, param: &ast::TyParam) -> IoResult<()> {
try!(self.print_ident(param.ident));
- try!(self.print_bounds(":", param.bounds[]));
+ try!(self.print_bounds(":", param.bounds.index(&FullRange)));
match param.default {
Some(ref default) => {
try!(space(&mut self.s));
try!(word(&mut self.s, name.get()));
try!(self.popen());
try!(self.commasep(Consistent,
- items[],
+ items.index(&FullRange),
|s, i| s.print_meta_item(&**i)));
try!(self.pclose());
}
try!(self.print_path(path, false));
try!(word(&mut self.s, "::{"));
}
- try!(self.commasep(Inconsistent, idents[], |s, w| {
+ try!(self.commasep(Inconsistent, idents.index(&FullRange), |s, w| {
match w.node {
ast::PathListIdent { name, .. } => {
s.print_ident(name)
pub fn print_view_item(&mut self, item: &ast::ViewItem) -> IoResult<()> {
try!(self.hardbreak_if_not_bol());
try!(self.maybe_print_comment(item.span.lo));
- try!(self.print_outer_attributes(item.attrs[]));
+ try!(self.print_outer_attributes(item.attrs.index(&FullRange)));
try!(self.print_visibility(item.vis));
match item.node {
ast::ViewItemExternCrate(id, ref optional_path, _) => {
try!(self.pclose());
}
- try!(self.print_bounds(":", bounds[]));
+ try!(self.print_bounds(":", bounds.index(&FullRange)));
try!(self.print_fn_output(decl));
try!(self.maybe_print_comment(lit.span.lo));
match self.next_lit(lit.span.lo) {
Some(ref ltrl) => {
- return word(&mut self.s, (*ltrl).lit[]);
+ return word(&mut self.s, (*ltrl).lit.index(&FullRange));
}
_ => ()
}
let mut res = String::from_str("b'");
ascii::escape_default(byte, |c| res.push(c as char));
res.push('\'');
- word(&mut self.s, res[])
+ word(&mut self.s, res.index(&FullRange))
}
ast::LitChar(ch) => {
let mut res = String::from_str("'");
res.push(c);
}
res.push('\'');
- word(&mut self.s, res[])
+ word(&mut self.s, res.index(&FullRange))
}
ast::LitInt(i, t) => {
match t {
ast::SignedIntLit(st, ast::Plus) => {
word(&mut self.s,
- ast_util::int_ty_to_string(st, Some(i as i64))[])
+ ast_util::int_ty_to_string(st, Some(i as i64)).index(&FullRange))
}
ast::SignedIntLit(st, ast::Minus) => {
let istr = ast_util::int_ty_to_string(st, Some(-(i as i64)));
word(&mut self.s,
- format!("-{}", istr)[])
+ format!("-{}", istr).index(&FullRange))
}
ast::UnsignedIntLit(ut) => {
- word(&mut self.s, ast_util::uint_ty_to_string(ut, Some(i))[])
+ word(&mut self.s, ast_util::uint_ty_to_string(ut, Some(i)).as_slice())
}
ast::UnsuffixedIntLit(ast::Plus) => {
- word(&mut self.s, format!("{}", i)[])
+ word(&mut self.s, format!("{}", i).index(&FullRange))
}
ast::UnsuffixedIntLit(ast::Minus) => {
- word(&mut self.s, format!("-{}", i)[])
+ word(&mut self.s, format!("-{}", i).index(&FullRange))
}
}
}
format!(
"{}{}",
f.get(),
- ast_util::float_ty_to_string(t)[])[])
+ ast_util::float_ty_to_string(t).index(&FullRange)).index(&FullRange))
}
ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, f.get()),
ast::LitBool(val) => {
ascii::escape_default(ch as u8,
|ch| escaped.push(ch as char));
}
- word(&mut self.s, format!("b\"{}\"", escaped)[])
+ word(&mut self.s, format!("b\"{}\"", escaped).index(&FullRange))
}
}
}
comments::Mixed => {
assert_eq!(cmnt.lines.len(), 1u);
try!(zerobreak(&mut self.s));
- try!(word(&mut self.s, cmnt.lines[0][]));
+ try!(word(&mut self.s, cmnt.lines[0].index(&FullRange)));
zerobreak(&mut self.s)
}
comments::Isolated => {
// Don't print empty lines because they will end up as trailing
// whitespace
if !line.is_empty() {
- try!(word(&mut self.s, line[]));
+ try!(word(&mut self.s, line.index(&FullRange)));
}
try!(hardbreak(&mut self.s));
}
comments::Trailing => {
try!(word(&mut self.s, " "));
if cmnt.lines.len() == 1u {
- try!(word(&mut self.s, cmnt.lines[0][]));
+ try!(word(&mut self.s, cmnt.lines[0].index(&FullRange)));
hardbreak(&mut self.s)
} else {
try!(self.ibox(0u));
for line in cmnt.lines.iter() {
if !line.is_empty() {
- try!(word(&mut self.s, line[]));
+ try!(word(&mut self.s, line.index(&FullRange)));
}
try!(hardbreak(&mut self.s));
}
string=st))
}
};
- word(&mut self.s, st[])
+ word(&mut self.s, st.index(&FullRange))
}
pub fn next_comment(&mut self) -> Option<comments::Comment> {
Some(abi::Rust) => Ok(()),
Some(abi) => {
try!(self.word_nbsp("extern"));
- self.word_nbsp(abi.to_string()[])
+ self.word_nbsp(abi.to_string().index(&FullRange))
}
None => Ok(())
}
match opt_abi {
Some(abi) => {
try!(self.word_nbsp("extern"));
- self.word_nbsp(abi.to_string()[])
+ self.word_nbsp(abi.to_string().index(&FullRange))
}
None => Ok(())
}
if abi != abi::Rust {
try!(self.word_nbsp("extern"));
- try!(self.word_nbsp(abi.to_string()[]));
+ try!(self.word_nbsp(abi.to_string().index(&FullRange)));
}
word(&mut self.s, "fn")
}
}
-#[cfg(stage0)]
-impl<E, D: Decoder<E>, T: 'static + Decodable<D, E>> Decodable<D, E> for P<T> {
- fn decode(d: &mut D) -> Result<P<T>, E> {
- Decodable::decode(d).map(P)
- }
-}
-
-#[cfg(not(stage0))]
impl<T: 'static + Decodable> Decodable for P<T> {
fn decode<D: Decoder>(d: &mut D) -> Result<P<T>, D::Error> {
Decodable::decode(d).map(P)
}
}
-#[cfg(stage0)]
-impl<E, S: Encoder<E>, T: Encodable<S, E>> Encodable<S, E> for P<T> {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- (**self).encode(s)
- }
-}
-
-#[cfg(not(stage0))]
impl<T: Encodable> Encodable for P<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s)
}
fn use_std(krate: &ast::Crate) -> bool {
- !attr::contains_name(krate.attrs[], "no_std")
+ !attr::contains_name(krate.attrs.index(&FullRange), "no_std")
}
fn no_prelude(attrs: &[ast::Attribute]) -> bool {
// The name to use in `extern crate "name" as std;`
let actual_crate_name = match self.alt_std_name {
- Some(ref s) => token::intern_and_get_ident(s[]),
+ Some(ref s) => token::intern_and_get_ident(s.index(&FullRange)),
None => token::intern_and_get_ident("std"),
};
attr::mark_used(&no_std_attr);
krate.attrs.push(no_std_attr);
- if !no_prelude(krate.attrs[]) {
+ if !no_prelude(krate.attrs.index(&FullRange)) {
// only add `use std::prelude::*;` if there wasn't a
// `#![no_implicit_prelude]` at the crate level.
// fold_mod() will insert glob path.
}
fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
- if !no_prelude(item.attrs[]) {
+ if !no_prelude(item.attrs.index(&FullRange)) {
// only recur if there wasn't `#![no_implicit_prelude]`
// on this item, i.e. this means that the prelude is not
// implicitly imported though the whole subtree
// We generate the test harness when building in the 'test'
// configuration, either with the '--test' or '--cfg test'
// command line options.
- let should_test = attr::contains_name(krate.config[], "test");
+ let should_test = attr::contains_name(krate.config.index(&FullRange), "test");
// Check for #[reexport_test_harness_main = "some_name"] which
// creates a `use some_name = __test::main;`. This needs to be
// unconditional, so that the attribute is still marked as used in
// non-test builds.
let reexport_test_harness_main =
- attr::first_attr_value_str_by_name(krate.attrs[],
+ attr::first_attr_value_str_by_name(krate.attrs.index(&FullRange),
"reexport_test_harness_main");
if should_test {
self.cx.path.push(ident);
}
debug!("current path: {}",
- ast_util::path_name_i(self.cx.path[]));
+ ast_util::path_name_i(self.cx.path.index(&FullRange)));
if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) {
match i.node {
if !self.cx.path.is_empty() {
self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym));
} else {
- debug!("pushing nothing, sym: {}", sym);
+ debug!("pushing nothing, sym: {:?}", sym);
self.cx.toplevel_reexport = Some(sym);
}
}
// When not compiling with --test we should not compile the
// #[test] functions
config::strip_items(krate, |attrs| {
- !attr::contains_name(attrs[], "test") &&
- !attr::contains_name(attrs[], "bench")
+ !attr::contains_name(attrs.index(&FullRange), "test") &&
+ !attr::contains_name(attrs.index(&FullRange), "bench")
})
}
fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
- let has_test_attr = attr::contains_name(i.attrs[], "test");
+ let has_test_attr = attr::contains_name(i.attrs.index(&FullRange), "test");
fn has_test_signature(i: &ast::Item) -> HasTestSignature {
match &i.node {
}
fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
- let has_bench_attr = attr::contains_name(i.attrs[], "bench");
+ let has_bench_attr = attr::contains_name(i.attrs.index(&FullRange), "bench");
fn has_test_signature(i: &ast::Item) -> bool {
match i.node {
mod __test {
extern crate test (name = "test", vers = "...");
fn main() {
- test::test_main_static(::os::args()[], tests)
+ test::test_main_static(::os::args().index(&FullRange), tests)
}
static tests : &'static [test::TestDescAndFn] = &[
}
fn is_test_crate(krate: &ast::Crate) -> bool {
- match attr::find_crate_name(krate.attrs[]) {
- Some(ref s) if "test" == s.get()[] => true,
+ match attr::find_crate_name(krate.attrs.index(&FullRange)) {
+ Some(ref s) if "test" == s.get().index(&FullRange) => true,
_ => false
}
}
// creates $name: $expr
let field = |&: name, expr| ecx.field_imm(span, ecx.ident_of(name), expr);
- debug!("encoding {}", ast_util::path_name_i(path[]));
+ debug!("encoding {}", ast_util::path_name_i(path.index(&FullRange)));
// path to the #[test] function: "foo::bar::baz"
- let path_string = ast_util::path_name_i(path[]);
- let name_expr = ecx.expr_str(span, token::intern_and_get_ident(path_string[]));
+ let path_string = ast_util::path_name_i(path.index(&FullRange));
+ let name_expr = ecx.expr_str(span, token::intern_and_get_ident(path_string.index(&FullRange)));
// self::test::StaticTestName($name_expr)
let name_expr = ecx.expr_call(span,
vect: RefCell<Vec<T> >,
}
-// when traits can extend traits, we should extend index<Name,T> to get []
+// when traits can extend traits, we should extend index<Name,T> to get .index(&FullRange)
impl<T: Eq + Hash + Clone + 'static> Interner<T> {
pub fn new() -> Interner<T> {
Interner {
impl Ord for RcStr {
fn cmp(&self, other: &RcStr) -> Ordering {
- self[].cmp(other[])
+ self.index(&FullRange).cmp(other.index(&FullRange))
}
}
impl fmt::Show for RcStr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use std::fmt::Show;
- self[].fmt(f)
+ self.index(&FullRange).fmt(f)
}
}
impl BorrowFrom<RcStr> for str {
fn borrow_from(owned: &RcStr) -> &str {
- owned.string[]
+ owned.string.index(&FullRange)
}
}
impl Deref for RcStr {
type Target = str;
- fn deref(&self) -> &str { self.string[] }
+ fn deref(&self) -> &str { self.string.index(&FullRange) }
}
/// A StrInterner differs from Interner<String> in that it accepts
vect: RefCell<Vec<RcStr> >,
}
-/// When traits can extend traits, we should extend index<Name,T> to get []
+/// When traits can extend traits, we should extend index<Name,T> to get .index(&FullRange)
impl StrInterner {
pub fn new() -> StrInterner {
StrInterner {
html_playground_url = "http://play.rust-lang.org/")]
#![allow(unknown_features)]
-#![feature(macro_rules, phase, slicing_syntax, globs)]
-
+#![feature(slicing_syntax)]
#![deny(missing_docs)]
-#[cfg(stage0)]
-#[phase(plugin, link)]
-extern crate log;
-
-#[cfg(not(stage0))]
-#[macro_use]
-extern crate log;
+#[macro_use] extern crate log;
pub use terminfo::TerminfoTerminal;
#[cfg(windows)]
}
};
- let entry = open(term[]);
+ let entry = open(term.index(&FullRange));
if entry.is_err() {
if os::getenv("MSYSCON").map_or(false, |s| {
"mintty.exe" == s
ti: msys_terminfo(),
num_colors: 8} as Box<Terminal<T>+Send>);
}
- debug!("error finding terminfo entry: {}", entry.err().unwrap());
+ debug!("error finding terminfo entry: {:?}", entry.err().unwrap());
return None;
}
let mut file = entry.unwrap();
let ti = parse(&mut file, false);
if ti.is_err() {
- debug!("error parsing terminfo entry: {}", ti.unwrap_err());
+ debug!("error parsing terminfo entry: {:?}", ti.unwrap_err());
return None;
}
';' => (),
_ => {
- return Err(format!("unrecognized format option {}", cur))
+ return Err(format!("unrecognized format option {:?}", cur))
}
}
},
s
}
_ => {
- return Err(format!("non-string on stack with %{}",
+ return Err(format!("non-string on stack with %{:?}",
op.to_char()))
}
}
"Binop {} succeeded incorrectly with 1 stack entry", cap);
let res = get_res("%{1}%{2}", cap, &[], vars);
assert!(res.is_ok(),
- "Binop {} failed with 2 stack entries: {}", cap, res.unwrap_err());
+ "Binop {} failed with 2 stack entries: {:?}", cap, res.unwrap_err());
}
}
macro_rules! try { ($e:expr) => (
match $e {
Ok(e) => e,
- Err(e) => return Err(format!("{}", e))
+ Err(e) => return Err(format!("{:?}", e))
}
) }
// Find the offset of the NUL we want to go to
- let nulpos = string_table[offset as uint .. string_table_bytes as uint]
+ let nulpos = string_table.index(&((offset as uint) .. (string_table_bytes as uint)))
.iter().position(|&b| b == 0);
match nulpos {
Some(len) => {
string_map.insert(name.to_string(),
- string_table[offset as uint ..
- offset as uint + len].to_vec())
+ string_table.index(&((offset as uint) ..
+ (offset as uint + len))).to_vec())
},
None => {
return Err("invalid file: missing NUL in \
for p in dirs_to_search.iter() {
if p.exists() {
let f = first_char.to_string();
- let newp = p.join_many(&[f[], term]);
+ let newp = p.join_many(&[f.index(&FullRange), term]);
if newp.exists() {
return Some(box newp);
}
// on some installations the dir is named after the hex of the char (e.g. OS X)
let f = format!("{:x}", first_char as uint);
- let newp = p.join_many(&[f[], term]);
+ let newp = p.join_many(&[f.index(&FullRange), term]);
if newp.exists() {
return Some(box newp);
}
Some(x) => {
match File::open(&*x) {
Ok(file) => Ok(file),
- Err(e) => Err(format!("error opening file: {}", e)),
+ Err(e) => Err(format!("error opening file: {:?}", e)),
}
}
None => {
- Err(format!("could not find terminfo entry for {}", term))
+ Err(format!("could not find terminfo entry for {:?}", term))
}
}
}
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-
-#![allow(unknown_features)]
-#![feature(asm, globs, slicing_syntax)]
-#![feature(unboxed_closures, default_type_params)]
-#![feature(old_orphan_check)]
+#![feature(asm, slicing_syntax)]
extern crate getopts;
extern crate regex;
// colons. This way if some test runner wants to arrange the tests
// hierarchically it may.
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash, Show)]
pub enum TestName {
StaticTestName(&'static str),
DynTestName(String)
}
}
}
-impl Show for TestName {
+impl fmt::String for TestName {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.as_slice().fmt(f)
+ fmt::String::fmt(self.as_slice(), f)
}
}
let opts =
match parse_opts(args) {
Some(Ok(o)) => o,
- Some(Err(msg)) => panic!("{}", msg),
+ Some(Err(msg)) => panic!("{:?}", msg),
None => return
};
match run_tests_console(&opts, tests) {
Ok(true) => {}
Ok(false) => panic!("Some tests failed"),
- Err(e) => panic!("io error when running tests: {}", e),
+ Err(e) => panic!("io error when running tests: {:?}", e),
}
}
let s = matches.free[0].as_slice();
match Regex::new(s) {
Ok(re) => Some(re),
- Err(e) => return Some(Err(format!("could not parse /{}/: {}", s, e)))
+ Err(e) => return Some(Err(format!("could not parse /{}/: {:?}", s, e)))
}
} else {
None
let ratchet_success = match *ratchet_metrics {
None => true,
Some(ref pth) => {
- try!(self.write_plain(format!("\nusing metrics ratchet: {}\n",
+ try!(self.write_plain(format!("\nusing metrics ratchet: {:?}\n",
pth.display()).as_slice()));
match ratchet_pct {
None => (),
None => (),
Some(ref pth) => {
try!(st.metrics.save(pth));
- try!(st.write_plain(format!("\nmetrics saved to: {}",
+ try!(st.write_plain(format!("\nmetrics saved to: {:?}",
pth.display()).as_slice()));
}
}
st.write_failures().unwrap();
let s = match st.out {
- Raw(ref m) => String::from_utf8_lossy(m[]),
+ Raw(ref m) => String::from_utf8_lossy(m.index(&FullRange)),
Pretty(_) => unreachable!()
};
cfg = cfg.stderr(box stderr as Box<Writer + Send>);
}
- let result_guard = cfg.spawn(move || { testfn.invoke(()) });
+ let result_guard = cfg.scoped(move || { testfn.invoke(()) });
let stdout = reader.read_to_end().unwrap().into_iter().collect();
let test_result = calc_result(&desc, result_guard.join());
monitor_ch.send((desc.clone(), test_result, stdout)).unwrap();
- }).detach();
+ });
}
match testfn {
let mut decoder = json::Decoder::new(value);
MetricMap(match Decodable::decode(&mut decoder) {
Ok(t) => t,
- Err(e) => panic!("failure decoding JSON: {}", e)
+ Err(e) => panic!("failure decoding JSON: {:?}", e)
})
}
use std::cmp::Ordering::{self, Less, Greater, Equal};
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::collections::hash_map;
-use std::fmt::Show;
+use std::fmt;
use std::hash::Hash;
use std::io;
use std::mem;
}
/// Render writes the min, max and quartiles of the provided `Summary` to the provided `Writer`.
-pub fn write_5_number_summary<W: Writer, T: Float + Show>(w: &mut W,
+pub fn write_5_number_summary<W: Writer, T: Float + fmt::String + fmt::Show>(w: &mut W,
s: &Summary<T>) -> io::IoResult<()> {
let (q1,q2,q3) = s.quartiles;
write!(w, "(min={}, q1={}, med={}, q3={}, max={})",
/// ```{.ignore}
/// 10 | [--****#******----------] | 40
/// ```
-pub fn write_boxplot<W: Writer, T: Float + Show + FromPrimitive>(
+pub fn write_boxplot<W: Writer, T: Float + fmt::String + fmt::Show + FromPrimitive>(
w: &mut W,
s: &Summary<T>,
width_hint: uint)
{
let mut map: hash_map::HashMap<U,uint> = hash_map::HashMap::new();
for elem in iter {
- match map.entry(&elem) {
+ match map.entry(elem) {
Occupied(mut entry) => { *entry.get_mut() += 1; },
Vacant(entry) => { entry.insert(1); },
}
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
#![no_std]
-#![feature(globs, macro_rules, slicing_syntax, unboxed_closures)]
-#![feature(associated_types)]
+#![feature(slicing_syntax)]
extern crate core;
}
pub mod grapheme {
- use core::kinds::Copy;
+ use core::marker::Copy;
use core::slice::SliceExt;
pub use self::GraphemeCat::*;
use core::result::Result::{Ok, Err};
-Subproject commit b820135911e17c7a46b901db56baa48e5155bf46
+Subproject commit ec1fdb3b9d3b1fb9e1dae97a65dd3a13db9bfb23
-Subproject commit b5ac4cd44321da10dfd70f070dbc9094ca3f92ff
+Subproject commit 3a37981744a5af2433fed551f742465c78c9af7f
+S 2015-01-06 340ac04
+ freebsd-x86_64 5413b8931d7076e90c873e0cc7a43e0793c2b17a
+ linux-i386 cacb8e3ad15937916e455d8f63e740c30a807b10
+ linux-x86_64 e4a7f73959130671a5eb9107d593d37b43e571b0
+ macos-i386 da6b0b7d12964e815175eb1fe5fc495098ca3125
+ macos-x86_64 edf8a109e175be6e5bc44484261d2248946f1dd1
+ winnt-i386 34fc7d9905d5845cdc7901f661d43a463534a20d
+ winnt-x86_64 99580840f5763f517f47cd55ff373e4d116b018d
+
S 2015-01-04 b2085d9
freebsd-x86_64 50ccb6bf9c0645d0746a5167493a39b2be40c2d4
linux-i386 b880b98d832c9a049b8ef6a50df50061e363de5a
let (tx, rx) = channel();
Thread::spawn(move|| {
tx.send(x.clone());
- }).detach();
+ });
rx
}
pub name : String,
}
- impl fmt::Show for cat {
+ impl fmt::String for cat {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.name)
}
// issue 8134
struct Foo;
-impl<T> Foo {
- pub fn foo(&self) {
+impl Foo {
+ pub fn foo<T>(&self) {
static X: uint = 1;
}
}
}
struct Bar;
-impl<T> Foo {
- pub fn bar(&self) {
+impl Foo {
+ pub fn bar<T>(&self) {
static X: uint = 1;
}
}
let mut worker_results = Vec::new();
for _ in range(0u, workers) {
let to_child = to_child.clone();
- worker_results.push(Thread::spawn(move|| {
+ worker_results.push(Thread::scoped(move|| {
for _ in range(0u, size / workers) {
//println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes)).unwrap();
}
Thread::spawn(move|| {
server(&from_parent, &to_parent);
- }).detach();
+ });
for r in worker_results.into_iter() {
let _ = r.join();
let mut worker_results = Vec::new();
let from_parent = if workers == 1 {
let (to_child, from_parent) = channel();
- worker_results.push(Thread::spawn(move|| {
+ worker_results.push(Thread::scoped(move|| {
for _ in range(0u, size / workers) {
//println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes));
let (to_child, from_parent) = channel();
for _ in range(0u, workers) {
let to_child = to_child.clone();
- worker_results.push(Thread::spawn(move|| {
+ worker_results.push(Thread::scoped(move|| {
for _ in range(0u, size / workers) {
//println!("worker {}: sending {} bytes", i, num_bytes);
to_child.send(request::bytes(num_bytes));
};
Thread::spawn(move|| {
server(&from_parent, &to_parent);
- }).detach();
+ });
for r in worker_results.into_iter() {
let _ = r.join();
// Create a channel: B->A
let (btx, brx) = channel();
- let guard_a = Thread::spawn(move|| {
+ let guard_a = Thread::scoped(move|| {
let (tx, rx) = (atx, brx);
for _ in range(0, n) {
tx.send(()).unwrap();
}
});
- let guard_b = Thread::spawn(move|| {
+ let guard_b = Thread::scoped(move|| {
let (tx, rx) = (btx, arx);
for _ in range(0, n) {
rx.recv().unwrap();
let (tx, rx) = channel();
Thread::spawn(move|| {
tx.send(parfib(n-1));
- }).detach();
+ });
let m2 = parfib(n-2);
return (rx.recv().unwrap() + m2);
}
let mut messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
use std::num::Int;
let iterations = 2i.pow((max_depth - depth + min_depth) as uint);
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut chk = 0;
for i in range(1, iterations + 1) {
let arena = TypedArena::new();
let all = [Blue, Red, Yellow];
for aa in all.iter() {
for bb in all.iter() {
- println!("{} + {} -> {}", *aa, *bb, transform(*aa, *bb));
+ println!("{:?} + {:?} -> {:?}", *aa, *bb, transform(*aa, *bb));
}
}
}
let mut out = String::new();
for col in set.iter() {
out.push(' ');
- out.push_str(col.to_string().as_slice());
+ out.push_str(format!("{:?}", col).as_slice());
}
out
}
}
}
// log creatures met and evil clones of self
- let report = format!("{}{}", creatures_met, Number(evil_clones_met));
+ let report = format!("{}{:?}", creatures_met, Number(evil_clones_met));
to_rendezvous_log.send(report).unwrap();
}
from_rendezvous,
to_rendezvous,
to_rendezvous_log);
- }).detach();
+ });
to_creature
}).collect();
}
// print the total number of creatures met
- println!("{}\n", Number(creatures_met));
+ println!("{:?}\n", Number(creatures_met));
}
fn main() {
let d = idx / self.fact[i] as i32;
self.cnt[i] = d;
idx %= self.fact[i] as i32;
- for (place, val) in pp.iter_mut().zip(self.perm.p[..i+1].iter()) {
+ for (place, val) in pp.iter_mut().zip(self.perm.p[..(i+1)].iter()) {
*place = (*val) as u8
}
for (i, j) in range(0, N).zip(iter::count(0, k)) {
let max = cmp::min(j+k, perm.max());
- futures.push(Thread::spawn(move|| {
+ futures.push(Thread::scoped(move|| {
work(perm, j as uint, max as uint)
}))
}
copy_memory(buf.as_mut_slice(), alu);
let buf_len = buf.len();
copy_memory(buf.slice_mut(alu_len, buf_len),
- alu[..LINE_LEN]);
+ &alu[0..LINE_LEN]);
let mut pos = 0;
let mut bytes;
for i in range(0u, chars_left) {
buf[i] = self.nextc();
}
- self.out.write(buf[..chars_left])
+ self.out.write(&buf[0..chars_left])
}
}
}
n -= nb;
line[nb] = '\n' as u8;
- try!(wr.write(line[..nb+1]));
+ try!(wr.write(&line[..(nb+1)]));
}
Ok(())
}
let len = bb.len();
while ii < len - (nn - 1u) {
- it(bb[ii..ii+nn]);
+ it(&bb[ii..(ii+nn)]);
ii += 1u;
}
- return bb[len - (nn - 1u)..len].to_vec();
+ return bb[(len - (nn - 1u))..len].to_vec();
}
fn make_sequence_processor(sz: uint,
Thread::spawn(move|| {
make_sequence_processor(sz, &from_parent, &to_parent_);
- }).detach();
+ });
to_child
}).collect::<Vec<Sender<Vec<u8> >> >();
// Pull first frame.
for _ in range(0, frame) {
code = code.push_char(input[0]);
- input = input[1..];
+ input = &input[1..];
}
frequencies.lookup(code, BumpCallback);
while input.len() != 0 && input[0] != ('>' as u8) {
code = code.rotate(input[0], frame);
frequencies.lookup(code, BumpCallback);
- input = input[1..];
+ input = &input[1..];
}
frequencies
}
let nb_freqs: Vec<_> = range(1u, 3).map(|i| {
let input = input.clone();
- (i, Thread::spawn(move|| generate_frequencies(input.as_slice(), i)))
+ (i, Thread::scoped(move|| generate_frequencies(input.as_slice(), i)))
}).collect();
let occ_freqs: Vec<_> = OCCURRENCES.iter().map(|&occ| {
let input = input.clone();
- Thread::spawn(move|| generate_frequencies(input.as_slice(), occ.len()))
+ Thread::scoped(move|| generate_frequencies(input.as_slice(), occ.len()))
}).collect();
for (i, freq) in nb_freqs.into_iter() {
let mut precalc_i = Vec::with_capacity(h);
let precalc_futures = range(0, WORKERS).map(|i| {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut rs = Vec::with_capacity(w / WORKERS);
let mut is = Vec::with_capacity(w / WORKERS);
let vec_init_r = arc_init_r.clone();
let vec_init_i = arc_init_i.clone();
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut res: Vec<u8> = Vec::with_capacity((chunk_size * w) / 8);
let init_r_slice = vec_init_r.as_slice();
let mut data = Data::new();
search(&*masks, m, 1, List::Cons(m, &List::Nil), &mut data);
tx.send(data).unwrap();
- }).detach();
+ });
}
// collecting the results
} else {
let (tx1, rx) = channel();
let tx2 = tx1.clone();
- Thread::spawn(move|| pfib(&tx2, n - 1)).detach();
+ Thread::spawn(move|| pfib(&tx2, n - 1));
let tx2 = tx1.clone();
- Thread::spawn(move|| pfib(&tx2, n - 2)).detach();
+ Thread::spawn(move|| pfib(&tx2, n - 2));
tx.send(rx.recv().unwrap() + rx.recv().unwrap());
}
}
let (tx, rx) = channel();
- Thread::spawn(move|| pfib(&tx, n) ).detach();
+ Thread::spawn(move|| pfib(&tx, n) );
rx.recv().unwrap()
}
fn stress(num_tasks: int) {
let mut results = Vec::new();
for i in range(0, num_tasks) {
- results.push(Thread::spawn(move|| {
+ results.push(Thread::scoped(move|| {
stress_task(i);
}));
}
// boundary.
let f = Racy(&f as *const F as *const uint);
let raw = Racy(chunk.repr());
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let f = f.0 as *const F;
unsafe { (*f)(mem::transmute(raw.0)) }
})
// boundary.
let f = Racy(&f as *const _ as *const uint);
let raw = Racy(chunk.repr());
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let f = f.0 as *const F;
unsafe { (*f)(i * size, mem::transmute(raw.0)) }
})
tx.send(token);
for i in range(2, n_tasks + 1) {
let (tx, next_rx) = channel();
- Thread::spawn(move|| roundtrip(i, tx, rx)).detach();
+ Thread::spawn(move|| roundtrip(i, tx, rx));
rx = next_rx;
}
- Thread::spawn(move|| roundtrip(1, tx, rx)).detach();
+ Thread::spawn(move|| roundtrip(1, tx, rx));
}
fn roundtrip(id: int, tx: Sender<int>, rx: Receiver<int>) {
fn run(repeat: int, depth: int) {
for _ in range(0, repeat) {
let dur = Duration::span(|| {
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
recurse_or_panic(depth, None)
}).join();
});
} else {
tx.send(()).unwrap()
}
- }).detach();
+ });
}
fn main() {
fn f(n: uint) {
let mut i = 0u;
while i < n {
- let _ = Thread::spawn(move|| g()).join();
+ let _ = Thread::scoped(move|| g()).join();
i += 1u;
}
}
};
let n = args[1].parse().unwrap();
let mut i = 0u;
- while i < n { Thread::spawn(move|| f(n) ).detach(); i += 1u; }
+ while i < n { Thread::spawn(move|| f(n) ); i += 1u; }
}
// except according to those terms.
fn main() {
- let _x: int = [1i, 2, 3]; //~ ERROR expected int, found array of 3 elements
+ let _x: isize = [1is, 2, 3]; //~ ERROR expected isize, found array of 3 elements
- let x: &[int] = &[1, 2, 3];
- let _y: &int = x; //~ ERROR expected int, found slice
+ let x: &[isize] = &[1, 2, 3];
+ let _y: &isize = x; //~ ERROR expected isize, found slice
}
pub fn main() {
let a = 42i;
- foo1(a); //~ERROR expected uint, found struct Bar
- baz(&a); //~ERROR expected uint, found struct Bar
+ foo1(a); //~ERROR expected usize, found struct Bar
+ baz(&a); //~ERROR expected usize, found struct Bar
}
}
fn f<T:Foo<int>>(t: &T) {
- let u: <T as Foo<uint>>::Bar = t.get_bar();
- //~^ ERROR the trait `Foo<uint>` is not implemented for the type `T`
+ let u: <T as Foo<usize>>::Bar = t.get_bar();
+ //~^ ERROR the trait `Foo<usize>` is not implemented for the type `T`
}
fn main() { }
}
pub fn f1_int_int() {
- f1(2i, 4i);
- //~^ ERROR expected uint, found int
+ f1(2is, 4is);
+ //~^ ERROR expected usize, found isize
}
pub fn f1_int_uint() {
- f1(2i, 4u);
+ f1(2is, 4us);
}
pub fn f1_uint_uint() {
- f1(2u, 4u);
+ f1(2us, 4us);
//~^ ERROR the trait `Foo` is not implemented
//~| ERROR the trait `Foo` is not implemented
}
pub fn f1_uint_int() {
- f1(2u, 4i);
+ f1(2us, 4is);
//~^ ERROR the trait `Foo` is not implemented
//~| ERROR the trait `Foo` is not implemented
}
pub fn f2_int() {
- let _: int = f2(2i);
- //~^ ERROR expected `int`, found `uint`
+ let _: int = f2(2is);
+ //~^ ERROR expected `isize`, found `usize`
}
pub fn main() { }
}
fn foo<T:Get>(t: T) {
- let x = t.get(); //~ ERROR the trait `core::kinds::Sized` is not implemented
+ let x = t.get(); //~ ERROR the trait `core::marker::Sized` is not implemented
}
fn main() {
// except according to those terms.
struct clam {
- x: Box<int>,
- y: Box<int>,
+ x: Box<isize>,
+ y: Box<isize>,
}
struct fish {
- a: Box<int>,
+ a: Box<isize>,
}
fn main() {
let a: clam = clam{x: box 1, y: box 2};
let b: clam = clam{x: box 10, y: box 20};
- let z: int = a.x + b.y; //~ ERROR binary operation `+` cannot be applied to type `Box<int>`
+ let z: isize = a.x + b.y; //~ ERROR binary operation `+` cannot be applied to type `Box<isize>`
println!("{}", z);
assert_eq!(z, 21);
let forty: fish = fish{a: box 40};
let two: fish = fish{a: box 2};
let answer: int = forty.a + two.a;
- //~^ ERROR binary operation `+` cannot be applied to type `Box<int>`
+ //~^ ERROR binary operation `+` cannot be applied to type `Box<isize>`
println!("{}", answer);
assert_eq!(answer, 42);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:expected `collections::string::String`, found `int`
+// error-pattern:expected `collections::string::String`, found `isize`
-static i: String = 10i;
+static i: String = 10is;
fn main() { println!("{}", i); }
// except according to those terms.
fn foo<T:'static>() {
- 1u.bar::<T>(); //~ ERROR `core::kinds::Send` is not implemented
+ 1u.bar::<T>(); //~ ERROR `core::marker::Send` is not implemented
}
trait bar {
pub fn main() {
let x: Vec<Trait + Sized> = Vec::new();
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
- //~^^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
+ //~^^ ERROR the trait `core::marker::Sized` is not implemented
let x: Vec<Box<RefCell<Trait + Sized>>> = Vec::new();
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:`&&` cannot be applied to type `int`
+// error-pattern:`&&` cannot be applied to type `isize`
-fn main() { let x = 1i && 2i; }
+fn main() { let x = 1is && 2is; }
}
fn has_mut_vec_and_does_not_try_to_change_it() {
- let mut v = vec!(1, 2, 3);
+ let mut v: Vec<int> = vec!(1, 2, 3);
takes_imm_elt(&v[0], || {})
}
fn has_mut_vec_but_tries_to_change_it() {
- let mut v = vec!(1, 2, 3);
+ let mut v: Vec<int> = vec!(1, 2, 3);
takes_imm_elt(
&v[0],
|| { //~ ERROR cannot borrow `v` as mutable
// Ensure that moves out of static items is forbidden
-use std::kinds::marker;
+use std::marker;
struct Foo {
foo: int,
}
}
let z = tail[0].clone();
- println!("{}", z);
+ println!("{:?}", z);
}
_ => {
unreachable!();
// move, when the struct implements Drop.
// NoCopy
-use std::kinds::marker::NoCopy as NP;
+use std::marker::NoCopy as NP;
struct S { a: int, np: NP }
trait Foo : Send+Sync { }
-impl <T: Sync+'static> Foo for (T,) { } //~ ERROR the trait `core::kinds::Send` is not implemented
+impl <T: Sync+'static> Foo for (T,) { } //~ ERROR the trait `core::marker::Send` is not implemented
-impl <T: Send> Foo for (T,T) { } //~ ERROR the trait `core::kinds::Sync` is not implemented
+impl <T: Send> Foo for (T,T) { } //~ ERROR the trait `core::marker::Sync` is not implemented
impl <T: Send+Sync> Foo for (T,T,T) { } // (ok)
impl <T:Sync> RequiresShare for X<T> { }
impl <T:Sync+'static> RequiresRequiresShareAndSend for X<T> { }
-//~^ ERROR the trait `core::kinds::Send` is not implemented
+//~^ ERROR the trait `core::marker::Send` is not implemented
fn main() { }
trait Foo : Send { }
-impl <T: Sync+'static> Foo for T { } //~ ERROR the trait `core::kinds::Send` is not implemented
+impl <T: Sync+'static> Foo for T { } //~ ERROR the trait `core::marker::Send` is not implemented
fn main() { }
// Verifies all possible restrictions for statics values.
-use std::kinds::marker;
+use std::marker;
struct WithDtor;
}
fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static {
- //~^ ERROR the trait `core::kinds::Send` is not implemented for the type
+ //~^ ERROR the trait `core::marker::Send` is not implemented for the type
return X { field: blk };
}
fn give_owned<F>(f: F) where F: FnOnce() + Send {
take_any(f);
- take_const_owned(f); //~ ERROR the trait `core::kinds::Sync` is not implemented for the type
+ take_const_owned(f); //~ ERROR the trait `core::marker::Sync` is not implemented for the type
}
fn main() {}
// Tests that we forbid coercion from `[T; n]` to `&[T]`
fn main() {
- let _: &[int] = [0i]; //~ERROR: mismatched types: expected `&[int]`, found `[int; 1]`
+ let _: &[isize] = [0is]; //~ERROR: mismatched types: expected `&[isize]`, found `[isize; 1]`
}
// aux-build:coherence-lib.rs
extern crate "coherence-lib" as lib;
-use lib::Remote;
+use lib::Remote1;
-impl<T> Remote for int { }
+impl<T> Remote1<T> for int { }
//~^ ERROR E0117
fn main() { }
fn test<T: Sync>() {}
fn main() {
- test::<Receiver<int>>(); //~ ERROR: `core::kinds::Sync` is not implemented
+ test::<Receiver<int>>(); //~ ERROR: `core::marker::Sync` is not implemented
}
fn test<T: Sync>() {}
fn main() {
- test::<Sender<int>>(); //~ ERROR: `core::kinds::Sync` is not implemented
+ test::<Sender<int>>(); //~ ERROR: `core::marker::Sync` is not implemented
}
let x = foo(10);
let _y = x.clone();
//~^ ERROR does not implement any method in scope
- println!("{}", x);
+ println!("{:?}", x);
}
let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
let z: Box<ToBar> = box Bar1 {f: 36};
f5.ptr = *z;
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
let f5: &mut Fat<ToBar> = &mut Fat { f1: 5, f2: "some str", ptr: Bar1 {f :42} };
let z: Box<ToBar> = box Bar1 {f: 36};
f5.ptr = Bar1 {f: 36}; //~ ERROR mismatched types: expected `ToBar`, found `Bar1`
- //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `ToBar`
+ //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `ToBar`
}
trait Bar {}
pub fn main() {
- // With a vec of ints.
+ // With a vec of isize.
let f1 = Fat { ptr: [1, 2, 3] };
- let f2: &Fat<[int; 3]> = &f1;
- let f3: &Fat<[uint]> = f2;
- //~^ ERROR mismatched types: expected `&Fat<[uint]>`, found `&Fat<[int; 3]>`
+ let f2: &Fat<[isize; 3]> = &f1;
+ let f3: &Fat<[usize]> = f2;
+ //~^ ERROR mismatched types: expected `&Fat<[usize]>`, found `&Fat<[isize; 3]>`
// With a trait.
let f1 = Fat { ptr: Foo };
}
pub fn main() {
- // With a vec of ints.
- let f1: &Fat<[int]> = &Fat { ptr: [1, 2, 3] };
- let f2: &Fat<[int; 3]> = f1;
- //~^ ERROR mismatched types: expected `&Fat<[int; 3]>`, found `&Fat<[int]>`
+ // With a vec of isizes.
+ let f1: &Fat<[isize]> = &Fat { ptr: [1, 2, 3] };
+ let f2: &Fat<[isize; 3]> = f1;
+ //~^ ERROR mismatched types: expected `&Fat<[isize; 3]>`, found `&Fat<[isize]>`
}
let f: Fat<[int; 3]> = Fat { ptr: [5i, 6, 7] };
let g: &Fat<[int]> = &f;
let h: &Fat<Fat<[int]>> = &Fat { ptr: *g };
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
fn test1<T: ?Sized + Foo>(t: &T) {
let u: &Foo = t;
- //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
+ //~^ ERROR `core::marker::Sized` is not implemented for the type `T`
}
fn test2<T: ?Sized + Foo>(t: &T) {
let v: &Foo = t as &Foo;
- //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
+ //~^ ERROR `core::marker::Sized` is not implemented for the type `T`
}
fn test3() {
let _: &[&Foo] = &["hi"];
- //~^ ERROR `core::kinds::Sized` is not implemented for the type `str`
+ //~^ ERROR `core::marker::Sized` is not implemented for the type `str`
}
fn test4() {
let _: &Foo = "hi" as &Foo;
- //~^ ERROR `core::kinds::Sized` is not implemented for the type `str`
+ //~^ ERROR `core::marker::Sized` is not implemented for the type `str`
}
fn main() { }
trait Foo<T> : Sized { fn take(self, x: &T) { } } // Note: T is sized
-impl Foo<[int]> for uint { }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[int]`
+impl Foo<[isize]> for usize { }
+//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[isize]`
-impl Foo<int> for [uint] { }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[uint]`
+impl Foo<isize> for [usize] { }
+//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[usize]`
pub fn main() { }
fn check_bound<T:Copy>(_: T) {}
fn main() {
- check_bound("nocopy".to_string()); //~ ERROR the trait `core::kinds::Copy` is not implemented
+ check_bound("nocopy".to_string()); //~ ERROR the trait `core::marker::Copy` is not implemented
}
#![feature(unboxed_closures)]
-fn needs_fn<F>(x: F) where F: Fn(int) -> int {}
+fn needs_fn<F>(x: F) where F: Fn(isize) -> isize {}
fn main() {
- let _: () = (box |:_: int| {}) as Box<FnOnce(int)>; //~ ERROR object-safe
- //~^ ERROR Box<core::ops::FnOnce(int)>
- let _: () = (box |&:_: int, int| {}) as Box<Fn(int, int)>;
- //~^ ERROR Box<core::ops::Fn(int, int)>
- let _: () = (box |&mut:| -> int unimplemented!()) as Box<FnMut() -> int>;
- //~^ ERROR Box<core::ops::FnMut() -> int>
+ let _: () = (box |:_: isize| {}) as Box<FnOnce(isize)>; //~ ERROR object-safe
+ //~^ ERROR Box<core::ops::FnOnce(isize)>
+ let _: () = (box |&:_: isize, isize| {}) as Box<Fn(isize, isize)>;
+ //~^ ERROR Box<core::ops::Fn(isize, isize)>
+ let _: () = (box |&mut:| -> isize unimplemented!()) as Box<FnMut() -> isize>;
+ //~^ ERROR Box<core::ops::FnMut() -> isize>
- needs_fn(1i); //~ ERROR `core::ops::Fn(int) -> int`
+ needs_fn(1i); //~ ERROR `core::ops::Fn(isize) -> isize`
}
// Test that we use fully-qualified type names in error messages.
fn main() {
- let x: Option<uint>;
+ let x: Option<usize>;
x = 5;
- //~^ ERROR mismatched types: expected `core::option::Option<uint>`
+ //~^ ERROR mismatched types: expected `core::option::Option<usize>`
}
use std::option::Option;
-fn bar(x: uint) -> Option<uint> {
+fn bar(x: usize) -> Option<usize> {
return x;
- //~^ ERROR mismatched types: expected `core::option::Option<uint>`
+ //~^ ERROR mismatched types: expected `core::option::Option<usize>`
}
fn main() {
fn main() {
// Ensure that the printed type doesn't include the default type params...
- let _: Foo<int> = ();
- //~^ ERROR mismatched types: expected `Foo<int>`, found `()`
+ let _: Foo<isize> = ();
+ //~^ ERROR mismatched types: expected `Foo<isize>`, found `()`
// ...even when they're present, but the same types as the defaults.
- let _: Foo<int, B, C> = ();
- //~^ ERROR mismatched types: expected `Foo<int>`, found `()`
+ let _: Foo<isize, B, C> = ();
+ //~^ ERROR mismatched types: expected `Foo<isize>`, found `()`
// Including cases where the default is using previous type params.
- let _: HashMap<String, int> = ();
- //~^ ERROR mismatched types: expected `HashMap<collections::string::String, int>`, found `()`
- let _: HashMap<String, int, Hash<String>> = ();
- //~^ ERROR mismatched types: expected `HashMap<collections::string::String, int>`, found `()`
+ let _: HashMap<String, isize> = ();
+ //~^ ERROR mismatched types: expected `HashMap<collections::string::String, isize>`, found `()`
+ let _: HashMap<String, isize, Hash<String>> = ();
+ //~^ ERROR mismatched types: expected `HashMap<collections::string::String, isize>`, found `()`
// But not when there's a different type in between.
- let _: Foo<A, int, C> = ();
- //~^ ERROR mismatched types: expected `Foo<A, int>`, found `()`
+ let _: Foo<A, isize, C> = ();
+ //~^ ERROR mismatched types: expected `Foo<A, isize>`, found `()`
// And don't print <> at all when there's just defaults.
let _: Foo<A, B, C> = ();
}
fn want_hrtb<T>()
- where T : for<'a> Foo<&'a int>
+ where T : for<'a> Foo<&'a isize>
{
}
-// AnyInt implements Foo<&'a int> for any 'a, so it is a match.
+// AnyInt implements Foo<&'a isize> for any 'a, so it is a match.
struct AnyInt;
-impl<'a> Foo<&'a int> for AnyInt { }
+impl<'a> Foo<&'a isize> for AnyInt { }
fn give_any() {
want_hrtb::<AnyInt>()
}
-// StaticInt only implements Foo<&'static int>, so it is an error.
+// StaticInt only implements Foo<&'static isize>, so it is an error.
struct StaticInt;
-impl Foo<&'static int> for StaticInt { }
+impl Foo<&'static isize> for StaticInt { }
fn give_static() {
- want_hrtb::<StaticInt>() //~ ERROR `for<'a> Foo<&'a int>` is not implemented
+ want_hrtb::<StaticInt>() //~ ERROR `for<'a> Foo<&'a isize>` is not implemented
}
fn main() { }
}
fn no_hrtb<'b,T>(mut t: T)
- where T : Bar<&'b int>
+ where T : Bar<&'b isize>
{
- // OK -- `T : Bar<&'b int>`, and thus the impl above ensures that
- // `&mut T : Bar<&'b int>`.
+ // OK -- `T : Bar<&'b isize>`, and thus the impl above ensures that
+ // `&mut T : Bar<&'b isize>`.
no_hrtb(&mut t);
}
fn bar_hrtb<T>(mut t: T)
- where T : for<'b> Bar<&'b int>
+ where T : for<'b> Bar<&'b isize>
{
- // OK -- `T : for<'b> Bar<&'b int>`, and thus the impl above
- // ensures that `&mut T : for<'b> Bar<&'b int>`. This is an
+ // OK -- `T : for<'b> Bar<&'b isize>`, and thus the impl above
+ // ensures that `&mut T : for<'b> Bar<&'b isize>`. This is an
// example of a "perfect forwarding" impl.
bar_hrtb(&mut t);
}
fn foo_hrtb_bar_not<'b,T>(mut t: T)
- where T : for<'a> Foo<&'a int> + Bar<&'b int>
+ where T : for<'a> Foo<&'a isize> + Bar<&'b isize>
{
// Not OK -- The forwarding impl for `Foo` requires that `Bar` also
// be implemented. Thus to satisfy `&mut T : for<'a> Foo<&'a
- // int>`, we require `T : for<'a> Bar<&'a int>`, but the where
- // clause only specifies `T : Bar<&'b int>`.
- foo_hrtb_bar_not(&mut t); //~ ERROR `for<'a> Bar<&'a int>` is not implemented for the type `T`
+ // isize>`, we require `T : for<'a> Bar<&'a isize>`, but the where
+ // clause only specifies `T : Bar<&'b isize>`.
+ foo_hrtb_bar_not(&mut t); //~ ERROR `for<'a> Bar<&'a isize>` is not implemented for the type `T`
}
fn foo_hrtb_bar_hrtb<T>(mut t: T)
- where T : for<'a> Foo<&'a int> + for<'b> Bar<&'b int>
+ where T : for<'a> Foo<&'a isize> + for<'b> Bar<&'b isize>
{
- // OK -- now we have `T : for<'b> Bar&'b int>`.
+ // OK -- now we have `T : for<'b> Bar&'b isize>`.
foo_hrtb_bar_hrtb(&mut t);
}
}
fn want_foo<T>()
- where T : for<'a> Foo<&'a int>
+ where T : for<'a> Foo<&'a isize>
{
}
x: X
}
-impl<'a,X> Foo<&'a int> for SomeStruct<X>
+impl<'a,X> Foo<&'a isize> for SomeStruct<X>
where X : 'a
{
}
fn one() {
// In fact there is no good reason for this to be an error, but
// whatever, I'm mostly concerned it doesn't ICE right now:
- want_foo::<SomeStruct<uint>>();
- //~^ ERROR requirement `for<'a> uint : 'a` is not satisfied
+ want_foo::<SomeStruct<usize>>();
+ //~^ ERROR requirement `for<'a> usize : 'a` is not satisfied
}
///////////////////////////////////////////////////////////////////////////
x: X
}
-impl<'a,X:'a> Foo<&'a int> for AnotherStruct<X>
+impl<'a,X:'a> Foo<&'a isize> for AnotherStruct<X>
{
}
fn two() {
- want_foo::<AnotherStruct<uint>>();
- //~^ ERROR requirement `for<'a> uint : 'a` is not satisfied
+ want_foo::<AnotherStruct<usize>>();
+ //~^ ERROR requirement `for<'a> usize : 'a` is not satisfied
}
fn main() { }
// except according to those terms.
fn main() {
- let x = if true { 10i } else { 10u };
- //~^ ERROR if and else have incompatible types: expected `int`, found `uint`
+ let x = if true { 10is } else { 10us };
+ //~^ ERROR if and else have incompatible types: expected `isize`, found `usize`
}
// bad syntax of the format string
- format!("{"); //~ ERROR: expected `}` but string was terminated
+ format!("{"); //~ ERROR: expected `'}'` but string was terminated
format!("foo } bar"); //~ ERROR: unmatched `}` found
format!("foo }"); //~ ERROR: unmatched `}` found
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct MyType;
+
+struct MyType1<T>(T);
+
+trait Bar {
+ type Out;
+}
+
+impl<T> MyType {
+ //~^ ERROR the type parameter `T` is not constrained
+}
+
+impl<T> MyType1<T> {
+ // OK, T is used in `Foo<T>`.
+}
+
+impl<T,U> MyType1<T> {
+ //~^ ERROR the type parameter `U` is not constrained
+}
+
+impl<T,U> MyType1<T> where T: Bar<Out=U> {
+ // OK, T is used in `Foo<T>`.
+}
+
+fn main() { }
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+trait Foo<A> {
+ fn get(&self, A: &A) { }
+}
+
+trait Bar {
+ type Out;
+}
+
+impl<T> Foo<T> for [int;0] {
+ // OK, T is used in `Foo<T>`.
+}
+
+impl<T,U> Foo<T> for [int;1] {
+ //~^ ERROR the type parameter `U` is not constrained
+}
+
+impl<T,U> Foo<T> for [int;2] where T : Bar<Out=U> {
+ // OK, `U` is now constrained by the output type parameter.
+}
+
+impl<T:Bar<Out=U>,U> Foo<T> for [int;3] {
+ // OK, same as above but written differently.
+}
+
+impl<T,U> Foo<T> for U {
+ // OK, T, U are used everywhere. Note that the coherence check
+ // hasn't executed yet, so no errors about overlap.
+}
+
+impl<T,U> Bar for T {
+ //~^ ERROR the type parameter `U` is not constrained
+
+ type Out = U;
+
+ // Using `U` in an associated type within the impl is not good enough!
+}
+
+impl<T,U> Bar for T
+ where T : Bar<Out=U>
+{
+ //~^^^ ERROR the type parameter `U` is not constrained
+
+ // This crafty self-referential attempt is still no good.
+}
+
+impl<T,U,V> Foo<T> for T
+ where (T,U): Bar<Out=V>
+{
+ //~^^^ ERROR the type parameter `U` is not constrained
+ //~| ERROR the type parameter `V` is not constrained
+
+ // Here, `V` is bound by an output type parameter, but the inputs
+ // are not themselves constrained.
+}
+
+impl<T,U,V> Foo<(T,U)> for T
+ where (T,U): Bar<Out=V>
+{
+ // As above, but both T and U ARE constrained.
+}
+
+fn main() { }
fn main() {
fn bar<T>(_: T) {}
- [0][0u8]; //~ ERROR: mismatched types
+ [0][0u8]; //~ ERROR: the trait `core::ops::Index<u8>` is not implemented
+ //~^ ERROR: the trait `core::ops::Index<u8>` is not implemented
[0][0]; // should infer to be a uint
pub fn main() {
let v: Vec<int> = vec!(0, 1, 2, 3, 4, 5);
let s: String = "abcdef".to_string();
- assert_eq!(v.as_slice()[3u], 3);
- assert_eq!(v.as_slice()[3u8], 3); //~ ERROR: mismatched types
- assert_eq!(v.as_slice()[3i8], 3); //~ ERROR: mismatched types
- assert_eq!(v.as_slice()[3u32], 3); //~ ERROR: mismatched types
- assert_eq!(v.as_slice()[3i32], 3); //~ ERROR: mismatched types
- println!("{}", v.as_slice()[3u8]); //~ ERROR: mismatched types
- assert_eq!(s.as_bytes()[3u], 'd' as u8);
- assert_eq!(s.as_bytes()[3u8], 'd' as u8); //~ ERROR: mismatched types
- assert_eq!(s.as_bytes()[3i8], 'd' as u8); //~ ERROR: mismatched types
- assert_eq!(s.as_bytes()[3u32], 'd' as u8); //~ ERROR: mismatched types
- assert_eq!(s.as_bytes()[3i32], 'd' as u8); //~ ERROR: mismatched types
- println!("{}", s.as_bytes()[3u8]); //~ ERROR: mismatched types
+ v.as_slice()[3u];
+ v.as_slice()[3];
+ v.as_slice()[3u8]; //~ERROR the trait `core::ops::Index<u8>` is not implemented
+ //~^ ERROR the trait `core::ops::Index<u8>` is not implemented
+ v.as_slice()[3i8]; //~ERROR the trait `core::ops::Index<i8>` is not implemented
+ //~^ ERROR the trait `core::ops::Index<i8>` is not implemented
+ v.as_slice()[3u32]; //~ERROR the trait `core::ops::Index<u32>` is not implemented
+ //~^ ERROR the trait `core::ops::Index<u32>` is not implemented
+ v.as_slice()[3i32]; //~ERROR the trait `core::ops::Index<i32>` is not implemented
+ //~^ ERROR the trait `core::ops::Index<i32>` is not implemented
+ s.as_bytes()[3u];
+ s.as_bytes()[3];
+ s.as_bytes()[3u8]; //~ERROR the trait `core::ops::Index<u8>` is not implemented
+ //~^ERROR the trait `core::ops::Index<u8>` is not implemented
+ s.as_bytes()[3i8]; //~ERROR the trait `core::ops::Index<i8>` is not implemented
+ //~^ERROR the trait `core::ops::Index<i8>` is not implemented
+ s.as_bytes()[3u32]; //~ERROR the trait `core::ops::Index<u32>` is not implemented
+ //~^ERROR the trait `core::ops::Index<u32>` is not implemented
+ s.as_bytes()[3i32]; //~ERROR the trait `core::ops::Index<i32>` is not implemented
+ //~^ERROR the trait `core::ops::Index<i32>` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn f() -> int {
+fn f() -> isize {
(return 1, return 2)
-//~^ ERROR mismatched types: expected `int`, found `(_, _)` (expected int, found tuple)
+//~^ ERROR mismatched types: expected `isize`, found `(_, _)` (expected isize, found tuple)
}
fn main() {}
fn main() {
let nil = ();
- let _t = nil as uint; //~ ERROR: cast from nil: `()` as `uint`
+ let _t = nil as usize; //~ ERROR: cast from nil: `()` as `usize`
}
fn result(&self) -> u64;
}
-trait StreamHasher<S: Stream> {
- fn stream(&self) -> S;
+trait StreamHasher {
+ type S : Stream;
+ fn stream(&self) -> Self::S;
}
//////////////////////////////////////////////////////////////////////////////
-trait StreamHash<S: Stream, H: StreamHasher<S>>: Hash<H> {
- fn input_stream(&self, stream: &mut S);
+trait StreamHash<H: StreamHasher>: Hash<H> {
+ fn input_stream(&self, stream: &mut H::S);
}
-impl<S: Stream, H: StreamHasher<S>> Hash<H> for u8 {
+impl<H: StreamHasher> Hash<H> for u8 {
fn hash2(&self, hasher: &H) -> u64 {
let mut stream = hasher.stream();
self.input_stream(&mut stream); //~ ERROR type annotations required
- stream.result()
+ Stream::result(&stream)
}
}
-impl<S: Stream, H: StreamHasher<S>> StreamHash<S, H> for u8 {
- fn input_stream(&self, stream: &mut S) {
- stream.input(&[*self]);
+impl<H: StreamHasher> StreamHash<H> for u8 {
+ fn input_stream(&self, stream: &mut H::S) {
+ Stream::input(&*stream, &[*self]);
}
}
//! Test that makes sure wrongly-typed bench functions are rejected
-// error-pattern:expected &-ptr, found int
+// error-pattern:expected &-ptr, found isize
#[bench]
-fn bar(x: int) { }
+fn bar(x: isize) { }
trait Itble<'r, T, I: Iterator<Item=T>> { fn iter(&'r self) -> I; }
-impl<'r> Itble<'r, uint, Range<uint>> for (uint, uint) {
- fn iter(&'r self) -> Range<uint> {
+impl<'r> Itble<'r, usize, Range<usize>> for (usize, usize) {
+ fn iter(&'r self) -> Range<usize> {
let &(min, max) = self;
range(min, max)
}
}
-fn check<'r, I: Iterator<Item=uint>, T: Itble<'r, uint, I>>(cont: &T) -> bool
-//~^ HELP as shown: fn check<'r, I: Iterator<Item = uint>, T: Itble<'r, uint, I>>(cont: &'r T)
+fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool
+//~^ HELP as shown: fn check<'r, I: Iterator<Item = usize>, T: Itble<'r, usize, I>>(cont: &'r T)
{
let cont_iter = cont.iter();
//~^ ERROR cannot infer an appropriate lifetime for autoref due to conflicting requirements
fn main() {
check((3u, 5u));
-//~^ ERROR mismatched types: expected `&_`, found `(uint, uint)` (expected &-ptr, found tuple)
+//~^ ERROR mismatched types: expected `&_`, found `(usize, usize)` (expected &-ptr, found tuple)
}
fn main() {
foo(1*(1 as int));
- //~^ ERROR: mismatched types: expected `i16`, found `int` (expected i16, found int)
+ //~^ ERROR: mismatched types: expected `i16`, found `isize` (expected i16, found isize)
bar(1*(1 as uint));
- //~^ ERROR: mismatched types: expected `u32`, found `uint` (expected u32, found uint)
+ //~^ ERROR: mismatched types: expected `u32`, found `usize` (expected u32, found usize)
}
// The expected arm type `Option<T>` has one type parameter, while
// the actual arm `Result<T, E>` has two. typeck should not be
// tricked into looking up a non-existing second type parameter.
- let _x: uint = match Some(1u) {
- Ok(u) => u, //~ ERROR mismatched types: expected `core::option::Option<uint>`
- Err(e) => panic!(e) //~ ERROR mismatched types: expected `core::option::Option<uint>`
+ let _x: usize = match Some(1us) {
+ Ok(u) => u, //~ ERROR mismatched types: expected `core::option::Option<usize>`
+ Err(e) => panic!(e) //~ ERROR mismatched types: expected `core::option::Option<usize>`
};
}
}
impl<'a, T: Deserializable> Deserializable for &'a str {
- //~^ ERROR unable to infer enough type information
+ //~^ ERROR type parameter `T` is not constrained
fn deserialize_token<D: Deserializer<'a>>(_x: D, _y: &'a str) -> &'a str {
}
}
fn main() {
let _x = "test" as &::std::any::Any;
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `str`
+//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `str`
}
fn main() {
let arr = &["one", "two", "three"];
- println!("{}", Something::yay(None::<X>, arr));
+ println!("{:?}", Something::yay(None::<X>, arr));
}
// except according to those terms.
fn main() {
- let x: Box<int> = box 0;
+ let x: Box<isize> = box 0;
- println!("{}", x + 1); //~ ERROR binary operation `+` cannot be applied to type `Box<int>`
+ println!("{}", x + 1); //~ ERROR binary operation `+` cannot be applied to type `Box<isize>`
}
impl<T: fmt::Show> ops::Fn<(), ()> for Shower<T> {
fn call(&self, _args: ()) {
//~^ ERROR `call` has an incompatible type for trait: expected "rust-call" fn, found "Rust" fn
- println!("{}", self.x);
+ println!("{:?}", self.x);
}
}
{
for
&something
-//~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `[T]`
+//~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[T]`
in arg2
{
}
#![deny(warnings)]
extern {
- pub fn foo(x: (int)); //~ ERROR found rust type `int` in foreign module
+ pub fn foo(x: (isize)); //~ ERROR found rust type `isize` in foreign module
}
fn main() {
static foo: *const Y::X = Y::foo(Y::x as *const Y::X);
//~^ ERROR cannot refer to other statics by value
-//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
+//~| ERROR: the trait `core::marker::Sync` is not implemented for the type
fn main() {}
trait Collection { fn len(&self) -> uint; }
impl<T, M: MatrixShape> Collection for Col<M, uint> {
-//~^ ERROR unable to infer enough type information
+//~^ ERROR type parameter `T` is not constrained
fn len(&self) -> uint {
unimplemented!()
}
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::ptr;
-use std::raw;
-
-trait Slice {}
-
-fn main() {
- unsafe {
- let nil: *const u8 = ptr::null();
- let slice: raw::Slice<u8> =
- Slice { //~ ERROR use of trait `Slice` as a struct constructor [E0159]
- data: nil,
- len: 0,
- };
- }
-}
// except according to those terms.
fn main() {
- let _foo = &[1u, 2] as [uint];
- //~^ ERROR cast to unsized type: `&[uint; 2]` as `[uint]`
- //~^^ HELP consider using an implicit coercion to `&[uint]` instead
+ let _foo = &[1u, 2] as [usize];
+ //~^ ERROR cast to unsized type: `&[usize; 2]` as `[usize]`
+ //~^^ HELP consider using an implicit coercion to `&[usize]` instead
let _bar = box 1u as std::fmt::Show;
- //~^ ERROR cast to unsized type: `Box<uint>` as `core::fmt::Show`
+ //~^ ERROR cast to unsized type: `Box<usize>` as `core::fmt::Show`
//~^^ HELP did you mean `Box<core::fmt::Show>`?
let _baz = 1u as std::fmt::Show;
- //~^ ERROR cast to unsized type: `uint` as `core::fmt::Show`
+ //~^ ERROR cast to unsized type: `usize` as `core::fmt::Show`
//~^^ HELP consider using a box or reference as appropriate
- let _quux = [1u, 2] as [uint];
- //~^ ERROR cast to unsized type: `[uint; 2]` as `[uint]`
+ let _quux = [1u, 2] as [usize];
+ //~^ ERROR cast to unsized type: `[usize; 2]` as `[usize]`
//~^^ HELP consider using a box or reference as appropriate
}
}
fn main() {
- let _x = Test::Foo as *const int;
- //~^ ERROR illegal cast; cast through an integer first: `Test` as `*const int`
+ let _x = Test::Foo as *const isize;
+ //~^ ERROR illegal cast; cast through an integer first: `Test` as `*const isize`
}
// and rejected.
fn main() {
- (|&:| box *[0u].as_slice())();
+ (|&:| box *[0us].as_slice())();
//~^ ERROR cannot move out of dereference
- //~^^ ERROR cannot move a value of type [uint]
+ //~^^ ERROR cannot move a value of type [usize]
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
struct Foo { nc: marker::NoCopy }
const INIT: Foo = Foo { nc: marker::NoCopy };
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
struct Foo { marker: marker::NoSync }
static FOO: uint = 3;
static BAR: Foo = Foo { marker: marker::NoSync };
-//~^ ERROR: the trait `core::kinds::Sync` is not implemented
+//~^ ERROR: the trait `core::marker::Sync` is not implemented
fn main() {}
fn main() {
let mut player = Player::new("Test player");
let mut room = Room::new("A test room");
- println!("Made a player: {}", player);
- println!("Direction parse: {}", str_to_direction("east"));
+ println!("Made a player: {:?}", player);
+ println!("Direction parse: {:?}", str_to_direction("east"));
match player.attemptTraverse(&room, "west") {
Ok(_) => println!("Was able to move west"),
Err(msg) => println!("Not able to move west: {}", msg)
impl Pair<
&str, //~ ERROR missing lifetime specifier
- int
+ isize
> {
- fn say(self: &Pair<&str, int>) {
-//~^ ERROR mismatched types: expected `Pair<&'static str, int>`, found `Pair<&str, int>`
+ fn say(self: &Pair<&str, isize>) {
+//~^ ERROR mismatched types: expected `Pair<&'static str, isize>`, found `Pair<&str, isize>`
println!("{}", self);
}
}
fn main() {
- let result = &Pair("shane", 1i);
+ let result = &Pair("shane", 1is);
result.say();
}
fn _create_render(_: &()) ->
AbstractRenderer
-//~^ ERROR: the trait `core::kinds::Sized` is not implemented
+//~^ ERROR: the trait `core::marker::Sized` is not implemented
{
match 0u {
_ => unimplemented!()
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn add_state(op: <int as HasState>::State) {
-//~^ ERROR the trait `HasState` is not implemented for the type `int`
+fn add_state(op: <isize as HasState>::State) {
+//~^ ERROR the trait `HasState` is not implemented for the type `isize`
}
trait HasState {
// This is a typo, the return type should be `<Dst as From<Self>>::Output`
fn to<Dst: From<Self>>(
self
- //~^ error: the trait `core::kinds::Sized` is not implemented
+ //~^ error: the trait `core::marker::Sized` is not implemented
) ->
<Dst as From<Self>>::Dst
- //~^ error: the trait `core::kinds::Sized` is not implemented
+ //~^ error: the trait `core::marker::Sized` is not implemented
{
From::from(
- //~^ error: the trait `core::kinds::Sized` is not implemented
+ //~^ error: the trait `core::marker::Sized` is not implemented
self
)
}
trait To {
fn to<Dst>(
- self //~ error: the trait `core::kinds::Sized` is not implemented
+ self //~ error: the trait `core::marker::Sized` is not implemented
) -> <Dst as From<Self>>::Result where Dst: From<Self> {
- From::from( //~ error: the trait `core::kinds::Sized` is not implemented
+ From::from( //~ error: the trait `core::marker::Sized` is not implemented
self
)
}
name: int
}
-fn bar(_x: Foo) {} //~ ERROR the trait `core::kinds::Sized` is not implemented
+fn bar(_x: Foo) {} //~ ERROR the trait `core::marker::Sized` is not implemented
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn bar(int_param: int) {}
+fn bar(int_param: usize) {}
fn main() {
- let foo: [u8; 4] = [1u8; 4u];
+ let foo: [u8; 4] = [1u8; 4us];
bar(foo);
- //~^ ERROR mismatched types: expected `int`, found `[u8; 4]`
- // (expected int, found vector)
+ //~^ ERROR mismatched types: expected `usize`, found `[u8; 4]`
+ // (expected usize, found vector)
}
// Regression test for issue #4968
-const A: (int,int) = (4,2);
+const A: (isize,isize) = (4,2);
fn main() {
match 42 { A => () }
- //~^ ERROR mismatched types: expected `_`, found `(int, int)`
+ //~^ ERROR mismatched types: expected `_`, found `(isize, isize)`
// (expected integral variable, found tuple)
}
trait I {}
type K = I+'static;
-fn foo(_x: K) {} //~ ERROR: the trait `core::kinds::Sized` is not implemented
+fn foo(_x: K) {} //~ ERROR: the trait `core::marker::Sized` is not implemented
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn main() { format!("{}", None); }
+fn main() { format!("{:?}", None); }
//~^ ERROR type annotations required
// Regression test for issue #5239
fn main() {
- let x = |&: ref x: int| -> int { x += 1; };
- //~^ ERROR binary assignment operation `+=` cannot be applied to type `&int`
+ let x = |&: ref x: isize| -> isize { x += 1; };
+ //~^ ERROR binary assignment operation `+=` cannot be applied to type `&isize`
}
fn main() {
let r: Box<Foo> = box 5;
let _m: Box<Foo> = r as Box<Foo>;
- //~^ ERROR `core::kinds::Sized` is not implemented for the type `Foo`
+ //~^ ERROR `core::marker::Sized` is not implemented for the type `Foo`
}
}
fn new_struct(r: A+'static)
- -> Struct { //~^ ERROR the trait `core::kinds::Sized` is not implemented
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ -> Struct { //~^ ERROR the trait `core::marker::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
Struct { r: r }
}
fn main() {
// Unconstrained type:
- format!("{}", None);
+ format!("{:?}", None);
//~^ ERROR type annotations required
}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern: unknown macro variable `nonexistent`
+
+macro_rules! e {
+ ($inp:ident) => (
+ $nonexistent
+ );
+}
+
+fn main() {
+ e!(foo);
+}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(macro_rules)]
+
+// error-pattern: unknown macro variable `nonexistent`
+
+macro_rules! g {
+ ($inp:ident) => (
+ { $inp $nonexistent }
+ );
+}
+
+fn main() {
+ g!(foo);
+}
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// error-pattern: unexpected token
-
-macro_rules! e {
- ($inp:ident) => (
- $nonexistent
- );
-}
-
-fn main() {
- e!(foo);
-}
fn main() {
let a = A {v: box B{v: None} as Box<Foo+Send>};
- //~^ ERROR the trait `core::kinds::Send` is not implemented
- //~^^ ERROR the trait `core::kinds::Send` is not implemented
+ //~^ ERROR the trait `core::marker::Send` is not implemented
+ //~^^ ERROR the trait `core::marker::Send` is not implemented
}
// Regresion test for issue 7364
static boxed: Box<RefCell<int>> = box RefCell::new(0);
//~^ ERROR statics are not allowed to have custom pointers
-//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
-//~| ERROR: the trait `core::kinds::Sync` is not implemented for the type
+//~| ERROR: the trait `core::marker::Sync` is not implemented for the type
+//~| ERROR: the trait `core::marker::Sync` is not implemented for the type
fn main() { }
// Test the mechanism for warning about possible missing `self` declarations.
trait CtxtFn {
- fn f8(self, uint) -> uint;
- fn f9(uint) -> uint; //~ NOTE candidate
+ fn f8(self, usize) -> usize;
+ fn f9(usize) -> usize; //~ NOTE candidate
}
trait OtherTrait {
- fn f9(uint) -> uint; //~ NOTE candidate
+ fn f9(usize) -> usize; //~ NOTE candidate
}
// Note: this trait is not implemented, but we can't really tell
// whether or not an impl would match anyhow without a self
-// declaration to match against, so we wind up printing it as a
+// declaration to match against, so we wind up prisizeing it as a
// candidate. This seems not unreasonable -- perhaps the user meant to
// implement it, after all.
trait UnusedTrait {
- fn f9(uint) -> uint; //~ NOTE candidate
+ fn f9(usize) -> usize; //~ NOTE candidate
}
-impl CtxtFn for uint {
- fn f8(self, i: uint) -> uint {
+impl CtxtFn for usize {
+ fn f8(self, i: usize) -> usize {
i * 4u
}
- fn f9(i: uint) -> uint {
+ fn f9(i: usize) -> usize {
i * 4u
}
}
-impl OtherTrait for uint {
- fn f9(i: uint) -> uint {
+impl OtherTrait for usize {
+ fn f9(i: usize) -> usize {
i * 8u
}
}
-struct MyInt(int);
+struct Myisize(isize);
-impl MyInt {
- fn fff(i: int) -> int { //~ NOTE candidate
+impl Myisize {
+ fn fff(i: isize) -> isize { //~ NOTE candidate
i
}
}
}
}
-impl ManyImplTrait for uint {}
-impl ManyImplTrait for int {}
+impl ManyImplTrait for usize {}
+impl ManyImplTrait for isize {}
impl ManyImplTrait for char {}
-impl ManyImplTrait for MyInt {}
+impl ManyImplTrait for Myisize {}
-fn no_param_bound(u: uint, m: MyInt) -> uint {
+fn no_param_bound(u: usize, m: Myisize) -> usize {
u.f8(42) + u.f9(342) + m.fff(42)
- //~^ ERROR type `uint` does not implement any method in scope named `f9`
+ //~^ ERROR type `usize` does not implement any method in scope named `f9`
//~^^ NOTE found defined static methods, maybe a `self` is missing?
- //~^^^ ERROR type `MyInt` does not implement any method in scope named `fff`
- //~^^^^ NOTE found defined static methods, maybe a `self` is missing?
+ //~^^^ ERROR type `Myisize` does not implement any method in scope named `fff`
+ //~^^^^ NOTE found defined static methods, maybe a `self` is missing?
}
fn param_bound<T: ManyImplTrait>(t: T) -> bool {
_ => ()
}
- match &Some(42i) {
- Some(x) => (), //~ ERROR expected `&core::option::Option<int>`,
+ match &Some(42is) {
+ Some(x) => (), //~ ERROR expected `&core::option::Option<isize>`,
// found `core::option::Option<_>`
- None => () //~ ERROR expected `&core::option::Option<int>`,
+ None => () //~ ERROR expected `&core::option::Option<isize>`,
// found `core::option::Option<_>`
}
}
enum Foo {
A = 1i64,
- //~^ ERROR mismatched types: expected `int`, found `i64`
+ //~^ ERROR mismatched types: expected `isize`, found `i64`
B = 2u8
- //~^ ERROR mismatched types: expected `int`, found `u8`
+ //~^ ERROR mismatched types: expected `isize`, found `u8`
}
fn main() {}
// except according to those terms.
#[start]
-fn start(argc: int, argv: *const *const u8, crate_map: *const u8) -> int {
+fn start(argc: isize, argv: *const *const u8, crate_map: *const u8) -> isize {
//~^ ERROR incorrect number of function parameters
- 0
+ 0
}
assert_copy::<&'a [int]>();
// ...unless they are mutable
- assert_copy::<&'static mut int>(); //~ ERROR `core::kinds::Copy` is not implemented
- assert_copy::<&'a mut int>(); //~ ERROR `core::kinds::Copy` is not implemented
+ assert_copy::<&'static mut int>(); //~ ERROR `core::marker::Copy` is not implemented
+ assert_copy::<&'a mut int>(); //~ ERROR `core::marker::Copy` is not implemented
// ~ pointers are not ok
- assert_copy::<Box<int>>(); //~ ERROR `core::kinds::Copy` is not implemented
- assert_copy::<String>(); //~ ERROR `core::kinds::Copy` is not implemented
- assert_copy::<Vec<int> >(); //~ ERROR `core::kinds::Copy` is not implemented
- assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::kinds::Copy` is not implemented
+ assert_copy::<Box<int>>(); //~ ERROR `core::marker::Copy` is not implemented
+ assert_copy::<String>(); //~ ERROR `core::marker::Copy` is not implemented
+ assert_copy::<Vec<int> >(); //~ ERROR `core::marker::Copy` is not implemented
+ assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::marker::Copy` is not implemented
// borrowed object types are generally ok
assert_copy::<&'a Dummy>();
assert_copy::<&'static (Dummy+Copy)>();
// owned object types are not ok
- assert_copy::<Box<Dummy>>(); //~ ERROR `core::kinds::Copy` is not implemented
- assert_copy::<Box<Dummy+Copy>>(); //~ ERROR `core::kinds::Copy` is not implemented
+ assert_copy::<Box<Dummy>>(); //~ ERROR `core::marker::Copy` is not implemented
+ assert_copy::<Box<Dummy+Copy>>(); //~ ERROR `core::marker::Copy` is not implemented
// mutable object types are not ok
- assert_copy::<&'a mut (Dummy+Copy)>(); //~ ERROR `core::kinds::Copy` is not implemented
+ assert_copy::<&'a mut (Dummy+Copy)>(); //~ ERROR `core::marker::Copy` is not implemented
// unsafe ptrs are ok
assert_copy::<*const int>();
assert_copy::<MyStruct>();
// structs containing non-POD are not ok
- assert_copy::<MyNoncopyStruct>(); //~ ERROR `core::kinds::Copy` is not implemented
+ assert_copy::<MyNoncopyStruct>(); //~ ERROR `core::marker::Copy` is not implemented
// ref counted types are not ok
- assert_copy::<Rc<int>>(); //~ ERROR `core::kinds::Copy` is not implemented
+ assert_copy::<Rc<int>>(); //~ ERROR `core::marker::Copy` is not implemented
}
pub fn main() {
fn main() {
let x = box 3i;
take_param(&x);
- //~^ ERROR the trait `core::kinds::Copy` is not implemented
+ //~^ ERROR the trait `core::marker::Copy` is not implemented
}
fn f<T>(val: T) {
let t: S<T> = S;
let a = &t as &Gettable<T>;
- //~^ ERROR the trait `core::kinds::Send` is not implemented
- //~^^ ERROR the trait `core::kinds::Copy` is not implemented
+ //~^ ERROR the trait `core::marker::Send` is not implemented
+ //~^^ ERROR the trait `core::marker::Copy` is not implemented
}
fn g<T>(val: T) {
let t: S<T> = S;
let a: &Gettable<T> = &t;
- //~^ ERROR the trait `core::kinds::Send` is not implemented
- //~^^ ERROR the trait `core::kinds::Copy` is not implemented
+ //~^ ERROR the trait `core::marker::Send` is not implemented
+ //~^^ ERROR the trait `core::marker::Copy` is not implemented
}
fn foo<'a>() {
fn foo2<'a>() {
let t: Box<S<String>> = box S;
let a = t as Box<Gettable<String>>;
- //~^ ERROR the trait `core::kinds::Copy` is not implemented
+ //~^ ERROR the trait `core::marker::Copy` is not implemented
}
fn foo3<'a>() {
let t: Box<S<String>> = box S;
let a: Box<Gettable<String>> = t;
- //~^ ERROR the trait `core::kinds::Copy` is not implemented
+ //~^ ERROR the trait `core::marker::Copy` is not implemented
}
fn main() { }
fn a() {
let x = box 3i;
- take_param(&x); //~ ERROR `core::kinds::Copy` is not implemented
+ take_param(&x); //~ ERROR `core::marker::Copy` is not implemented
}
fn b() {
let x = box 3i;
let y = &x;
- let z = &x as &Foo; //~ ERROR `core::kinds::Copy` is not implemented
+ let z = &x as &Foo; //~ ERROR `core::marker::Copy` is not implemented
}
fn main() { }
fn main() {
let x = Rc::new(3u);
bar(move|| foo(x));
- //~^ ERROR `core::kinds::Send` is not implemented
- //~^^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
+ //~^^ ERROR `core::marker::Send` is not implemented
}
fn object_ref_with_static_bound_not_ok() {
assert_send::<&'static (Dummy+'static)>();
- //~^ ERROR the trait `core::kinds::Send` is not implemented
+ //~^ ERROR the trait `core::marker::Send` is not implemented
}
fn box_object_with_no_bound_not_ok<'a>() {
- assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::kinds::Send` is not implemented
+ assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::marker::Send` is not implemented
}
fn object_with_send_bound_ok() {
// careful with object types, who knows what they close over...
fn test51<'a>() {
assert_send::<&'a Dummy>();
- //~^ ERROR the trait `core::kinds::Send` is not implemented
+ //~^ ERROR the trait `core::marker::Send` is not implemented
}
fn test52<'a>() {
assert_send::<&'a (Dummy+Send)>();
// them not ok
fn test_71<'a>() {
assert_send::<Box<Dummy+'a>>();
- //~^ ERROR the trait `core::kinds::Send` is not implemented
+ //~^ ERROR the trait `core::marker::Send` is not implemented
}
fn main() { }
trait Dummy { }
fn test50() {
- assert_send::<&'static Dummy>(); //~ ERROR the trait `core::kinds::Send` is not implemented
+ assert_send::<&'static Dummy>(); //~ ERROR the trait `core::marker::Send` is not implemented
}
fn test53() {
- assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::kinds::Send` is not implemented
+ assert_send::<Box<Dummy>>(); //~ ERROR the trait `core::marker::Send` is not implemented
}
// ...unless they are properly bounded
fn test71<'a>() {
assert_send::<*mut &'a int>();
- //~^ ERROR the trait `core::kinds::Send` is not implemented for the type
+ //~^ ERROR the trait `core::marker::Send` is not implemented for the type
}
fn main() {
}
fn main() {
- println!("{}", foo);
+ println!("{:?}", foo);
}
struct Foo {
x: uint,
b: bool, //~ ERROR: struct field is never used
- marker: std::kinds::marker::NoCopy
+ marker: std::marker::NoCopy
}
fn field_read(f: Foo) -> uint {
}
fn main() {
- field_read(Foo { x: 1, b: false, marker: std::kinds::marker::NoCopy });
+ field_read(Foo { x: 1, b: false, marker: std::marker::NoCopy });
field_match_in_patterns(XYZ::Z);
field_match_in_let(Bar { x: 42u, b: true, _guard: () });
let _ = Baz { x: 0 };
let mut buff = [0u8; 16];
match f.read(&mut buff) {
Ok(cnt) => println!("read this many bytes: {}", cnt),
- Err(IoError{ kind: EndOfFile, .. }) => println!("Got end of file: {}", EndOfFile.to_string()),
+ Err(IoError{ kind: EndOfFile, .. }) => println!("Got end of file: {:?}", EndOfFile),
//~^ ERROR variable `EndOfFile` should have a snake case name such as `end_of_file`
//~^^ WARN `EndOfFile` is named the same as one of the variants of the type `std::io::IoErrorKind`
}
// except according to those terms.
fn send<T:Send + std::fmt::Show>(ch: _chan<T>, data: T) {
- println!("{}", ch);
- println!("{}", data);
+ println!("{:?}", ch);
+ println!("{:?}", data);
panic!();
}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+macro_rules! errors_everywhere {
+ ($ty:ty <) => (); //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty`
+ ($ty:ty < foo ,) => (); //~ ERROR `$ty:ty` is followed by `<`, which is not allowed for `ty`
+ ($ty:ty , ) => ();
+ ( ( $ty:ty ) ) => ();
+ ( { $ty:ty } ) => ();
+ ( [ $ty:ty ] ) => ();
+ ($bl:block < ) => ();
+ ($pa:pat >) => (); //~ ERROR `$pa:pat` is followed by `>`, which is not allowed for `pat`
+ ($pa:pat , ) => ();
+ ($pa:pat | ) => (); //~ ERROR `$pa:pat` is followed by `|`
+ ($pa:pat $pb:pat $ty:ty ,) => ();
+ //~^ ERROR `$pa:pat` is followed by `$pb:pat`, which is not allowed
+ //~^^ ERROR `$pb:pat` is followed by `$ty:ty`, which is not allowed
+ ($($ty:ty)* -) => (); //~ ERROR `$ty:ty` is followed by `-`
+ ($($a:ty, $b:ty)* -) => (); //~ ERROR `$b:ty` is followed by `-`
+ ($($ty:ty)-+) => (); //~ ERROR `$ty:ty` is followed by `-`, which is not allowed for `ty`
+}
+
+fn main() { }
// Test that trait types printed in error msgs include the type arguments.
fn main() {
- let x: Box<HashMap<int, int>> = box HashMap::new();
- let x: Box<Map<int, int>> = x;
- let y: Box<Map<uint, int>> = box x;
- //~^ ERROR the trait `Map<uint, int>` is not implemented
+ let x: Box<HashMap<isize, isize>> = box HashMap::new();
+ let x: Box<Map<isize, isize>> = x;
+ let y: Box<Map<usize, isize>> = box x;
+ //~^ ERROR the trait `Map<usize, isize>` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
fn foo<P:Copy>(p: P) { }
fn main()
{
- foo(marker::NoCopy); //~ ERROR the trait `core::kinds::Copy` is not implemented
+ foo(marker::NoCopy); //~ ERROR the trait `core::marker::Copy` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
fn foo<P:Send>(p: P) { }
fn main()
{
- foo(marker::NoSend); //~ ERROR the trait `core::kinds::Send` is not implemented
+ foo(marker::NoSend); //~ ERROR the trait `core::marker::Send` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
fn foo<P: Sync>(p: P) { }
fn main()
{
- foo(marker::NoSync); //~ ERROR the trait `core::kinds::Sync` is not implemented
+ foo(marker::NoSync); //~ ERROR the trait `core::marker::Sync` is not implemented
}
let x = Foo;
Foo::bar(x); //~ERROR mismatched types: expected `&Foo`, found `Foo`
Foo::bar(&&x); //~ERROR mismatched types: expected `&Foo`, found `&&Foo`
- Foo::bar(&42i); //~ERROR mismatched types: expected `&Foo`, found `&int`
+ Foo::bar(&42is); //~ERROR mismatched types: expected `&Foo`, found `&isize`
}
fn main() {
let x = RefCell::new(0i);
f(x);
- //~^ ERROR `core::kinds::Sync` is not implemented
- //~^^ ERROR `core::kinds::Sync` is not implemented
+ //~^ ERROR `core::marker::Sync` is not implemented
+ //~^^ ERROR `core::marker::Sync` is not implemented
}
// except according to those terms.
fn main() {
- let foo = &mut 1i;
+ let foo = &mut 1is;
// (separate lines to ensure the spans are accurate)
- // SNAP b2085d9 uncomment this after the next snapshot
+ // SNAP 340ac04 uncomment this after the next snapshot
// NOTE(stage0) just in case tidy doesn't check snap's in tests
- // let &_ // ~ ERROR expected `&mut int`, found `&_`
+ // let &_ // ~ ERROR expected `&mut isize`, found `&_`
// = foo;
let &mut _ = foo;
- let bar = &1i;
+ let bar = &1is;
let &_ = bar;
- let &mut _ //~ ERROR expected `&int`, found `&mut _`
+ let &mut _ //~ ERROR expected `&isize`, found `&mut _`
= bar;
}
// Tests that an `&` pointer to something inherently mutable is itself
// to be considered mutable.
-use std::kinds::marker;
+use std::marker;
enum Foo { A(marker::NoSync) }
fn main() {
let x = Foo::A(marker::NoSync);
- bar(&x); //~ ERROR the trait `core::kinds::Sync` is not implemented
+ bar(&x); //~ ERROR the trait `core::marker::Sync` is not implemented
}
let x = foo(Port(Rc::new(())));
Thread::spawn(move|| {
- //~^ ERROR `core::kinds::Send` is not implemented
- //~^^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
+ //~^^ ERROR `core::marker::Send` is not implemented
let y = x;
- println!("{}", y);
+ println!("{:?}", y);
});
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
enum Foo {
A(marker::NoSend)
fn main() {
let x = Foo::A(marker::NoSend);
bar(x);
- //~^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
}
fn main() {
let x = Rc::new(5i);
bar(x);
- //~^ ERROR `core::kinds::Send` is not implemented
- //~^^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
+ //~^^ ERROR `core::marker::Send` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
struct Foo {
a: int,
fn main() {
let x = Foo { a: 5, ns: marker::NoSend };
bar(x);
- //~^ ERROR the trait `core::kinds::Send` is not implemented
+ //~^ ERROR the trait `core::marker::Send` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
enum Foo { A(marker::NoSync) }
fn main() {
let x = Foo::A(marker::NoSync);
bar(x);
- //~^ ERROR the trait `core::kinds::Sync` is not implemented
+ //~^ ERROR the trait `core::marker::Sync` is not implemented
}
fn main() {
let x = Rc::new(RefCell::new(5i));
bar(x);
- //~^ ERROR the trait `core::kinds::Sync` is not implemented
- //~^^ ERROR the trait `core::kinds::Sync` is not implemented
+ //~^ ERROR the trait `core::marker::Sync` is not implemented
+ //~^^ ERROR the trait `core::marker::Sync` is not implemented
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
struct Foo { a: int, m: marker::NoSync }
fn main() {
let x = Foo { a: 5, m: marker::NoSync };
bar(x);
- //~^ ERROR the trait `core::kinds::Sync` is not implemented
+ //~^ ERROR the trait `core::marker::Sync` is not implemented
}
// because the def_id associated with the type was
// not convertible to a path.
let x: int = noexporttypelib::foo();
- //~^ ERROR expected `int`, found `core::option::Option<int>`
+ //~^ ERROR expected `isize`, found `core::option::Option<isize>`
}
fn main() {
let x = foo(10);
let _y = x.clone(); //~ ERROR does not implement any method in scope
- println!("{}", x);
+ println!("{:?}", x);
}
enum CantCopyThisEither {
A,
- B(::std::kinds::marker::NoCopy),
+ B(::std::marker::NoCopy),
}
enum IWantToCopyThisToo {
let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 };
unsafe {
let oof: Oof<[u8; 5], i32> = mem::transmute(foo);
- println!("{} {}", oof.rab[], oof.zab);
+ println!("{} {}", &oof.rab[], oof.zab);
}
}
let foo = Foo { bar: 1, baz: 10 };
unsafe {
let oof: Oof = mem::transmute(foo);
- println!("{}", oof);
+ println!("{:?}", oof);
}
}
fn let_in<T, F>(x: T, f: F) where F: FnOnce(T) {}
fn main() {
- let_in(3u, |i| { assert!(i == 3i); });
- //~^ ERROR expected `uint`, found `int`
+ let_in(3u, |i| { assert!(i == 3is); });
+ //~^ ERROR expected `usize`, found `isize`
- let_in(3i, |i| { assert!(i == 3u); });
- //~^ ERROR expected `int`, found `uint`
+ let_in(3i, |i| { assert!(i == 3us); });
+ //~^ ERROR expected `isize`, found `usize`
}
// Unsized type.
let arr: &[_] = &[1u, 2, 3];
let range = (*arr)..;
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
// Note: see variance-regions-*.rs for the tests that check that the
// variance inference works in the first place.
-use std::kinds::marker;
+use std::marker;
// This is contravariant with respect to 'a, meaning that
// Contravariant<'foo> <: Contravariant<'static> because
// Note: see variance-regions-*.rs for the tests that check that the
// variance inference works in the first place.
-use std::kinds::marker;
+use std::marker;
struct Covariant<'a> {
marker: marker::CovariantLifetime<'a>
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
struct invariant<'a> {
marker: marker::InvariantLifetime<'a>
// Check that we correctly infer that b and c must be region
// parameterized because they reference a which requires a region.
-type a<'a> = &'a int;
+type a<'a> = &'a isize;
type b<'a> = Box<a<'a>>;
struct c<'a> {
}
fn set_f_bad(&mut self, b: Box<b>) {
- self.f = b; //~ ERROR mismatched types: expected `Box<Box<&'a int>>`, found `Box<Box<&int>>`
+ self.f = b;
+ //~^ ERROR mismatched types: expected `Box<Box<&'a isize>>`, found `Box<Box<&isize>>`
}
}
fn main() {
let a = Foo { x: 3 };
let _ = [ a; 5 ];
- //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `Foo`
+ //~^ ERROR the trait `core::marker::Copy` is not implemented for the type `Foo`
}
let a = [0; n]; //~ ERROR expected constant integer for repeat count, found variable
let b = [0; ()];
//~^ ERROR expected constant integer for repeat count, found non-constant expression
-//~^^ ERROR: expected `uint`, found `()`
+//~^^ ERROR: expected `usize`, found `()`
let c = [0; true]; //~ ERROR expected positive integer for repeat count, found boolean
- //~^ ERROR: expected `uint`, found `bool`
+ //~^ ERROR: expected `usize`, found `bool`
let d = [0; 0.5]; //~ ERROR expected positive integer for repeat count, found float
- //~^ ERROR: expected `uint`, found `_`
+ //~^ ERROR: expected `usize`, found `_`
let e = [0; "foo"]; //~ ERROR expected positive integer for repeat count, found string
- //~^ ERROR: expected `uint`, found `&'static str`
+ //~^ ERROR: expected `usize`, found `&'static str`
let f = [0; -4];
//~^ ERROR expected positive integer for repeat count, found negative integer
let f = [0u; -1];
fn main() {
let x = Foo;
- x[..]; //~ ERROR incorrect slicing expression: `[..]`
- //~^ NOTE use `expr[]` to construct a slice of the whole of expr
+ &x[..]; //~ ERROR incorrect slicing expression: `[..]`
+ //~^ NOTE use `&expr[]` to construct a slice of the whole of expr
}
fn main() {
let x = Foo;
- x[]; //~ ERROR cannot take a slice of a value with type `Foo`
- x[Foo..]; //~ ERROR cannot take a slice of a value with type `Foo`
- x[..Foo]; //~ ERROR cannot take a slice of a value with type `Foo`
- x[Foo..Foo]; //~ ERROR cannot take a slice of a value with type `Foo`
+ &x[]; //~ ERROR cannot index a value of type `Foo`
+ &x[Foo..]; //~ ERROR cannot index a value of type `Foo`
+ &x[..Foo]; //~ ERROR cannot index a value of type `Foo`
+ &x[Foo..Foo]; //~ ERROR cannot index a value of type `Foo`
}
let y;
{
let x: &[int] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough
- y = x[1..];
+ y = &x[1..];
}
}
let x: &[int] = &[1, 2, 3, 4, 5];
// Can't mutably slice an immutable slice
let slice: &mut [int] = &mut [0, 1];
- x[2..4] = slice; //~ ERROR cannot borrow
+ let _ = &mut x[2..4]; //~ERROR cannot borrow immutable dereference of `&`-pointer `*x` as mutabl
}
fn main() {
let x: &[int] = &[1, 2, 3, 4, 5];
// Immutable slices are not mutable.
- let y: &mut[_] = x[2..4]; //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutabl
+ let y: &mut[_] = &x[2..4]; //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutab
}
// Verifies that static items can't be moved
-use std::kinds::marker;
+use std::marker;
struct Foo {
foo: int,
fn main() {
let mut it = state_iter();
- println!("{}",it.next());
- println!("{}",it.next());
- println!("{}",it.next());
- println!("{}",it.next());
- println!("{}",it.next());
+ println!("{:?}",it.next());
+ println!("{:?}",it.next());
+ println!("{:?}",it.next());
+ println!("{:?}",it.next());
+ println!("{:?}",it.next());
}
pub fn main() {
let s: &str = "hello";
- let c: u8 = s[4]; //~ ERROR cannot index a value of type `&str`
+ let c: u8 = s[4]; //~ ERROR the trait `core::ops::Index<_>` is not implemented
+ //~^ ERROR the trait `core::ops::Index<_>` is not implemented
}
fn main() {
let pt = PointF {
- //~^ ERROR expected f32, found int
- x: 1i,
- y: 2i,
+ //~^ ERROR expected f32, found isize
+ x: 1is,
+ y: 2is,
};
let pt2 = Point::<f32> {
- //~^ ERROR expected f32, found int
- x: 3i,
- y: 4i,
+ //~^ ERROR expected f32, found isize
+ x: 3is,
+ y: 4is,
};
let pair = PairF {
- //~^ ERROR expected f32, found int
- x: 5i,
- y: 6i,
+ //~^ ERROR expected f32, found isize
+ x: 5is,
+ y: 6is,
};
- let pair2 = PairF::<int> {
- //~^ ERROR expected f32, found int
- x: 7i,
- y: 8i,
+ let pair2 = PairF::<isize> {
+ //~^ ERROR expected f32, found isize
+ x: 7is,
+ y: 8is,
};
- let pt3 = PointF::<int> {
+ let pt3 = PointF::<isize> {
//~^ ERROR wrong number of type arguments
- x: 9i,
- y: 10i,
+ x: 9is,
+ y: 10is,
};
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::Send;
+use std::marker::Send;
struct TestType;
#![feature(optin_builtin_traits)]
-use std::kinds::Send;
+use std::marker::Send;
struct TestType;
pub fn main() {
test_send::<rand::ThreadRng>();
- //~^ ERROR `core::kinds::Send` is not implemented
- //~^^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
+ //~^^ ERROR `core::marker::Send` is not implemented
}
fn test_error8_fn<T: B>(&self);
}
-impl Foo for int {
+impl Foo for isize {
// invalid bound for T, was defined as Eq in trait
fn test_error1_fn<T: Ord>(&self) {}
//~^ ERROR in method `test_error1_fn`, type parameter 0 requires bound `core::cmp::Ord`
trait Getter<T> { }
trait Trait {
- fn method<G:Getter<int>>();
+ fn method<G:Getter<isize>>();
}
-impl Trait for uint {
- fn method<G: Getter<uint>>() {}
- //~^ ERROR in method `method`, type parameter 0 requires bound `Getter<uint>`
+impl Trait for usize {
+ fn method<G: Getter<usize>>() {}
+ //~^ ERROR in method `method`, type parameter 0 requires bound `Getter<usize>`
}
fn main() {}
// This should emit the less confusing error, not the more confusing one.
fn foo(_x: Foo + Send) {
- //~^ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ERROR the trait `core::marker::Sized` is not implemented
}
fn main() { }
}
fn main() {
- let s: Box<Trait<int>> = box Struct { person: "Fred" };
- //~^ ERROR the trait `Trait<int>` is not implemented for the type `Struct`
+ let s: Box<Trait<isize>> = box Struct { person: "Fred" };
+ //~^ ERROR the trait `Trait<isize>` is not implemented for the type `Struct`
s.f(1);
}
impl T for int {}
fn main() {
- let x = &42i;
- x.foo(); //~ERROR: type `&int` does not implement any method in scope named `foo`
+ let x = &42is;
+ x.foo(); //~ERROR: type `&isize` does not implement any method in scope named `foo`
}
// Issue #6155
-fn first((value, _): (int, f64)) -> int { value }
+fn first((value, _): (isize, f64)) -> isize { value }
fn main() {
let y = first ((1,2.0,3));
//~^ ERROR expected a tuple with 2 elements, found one with 3 elements
let y = first ((1,));
- //~^ ERROR expected `(int, f64)`, found `(int,)`
+ //~^ ERROR expected `(isize, f64)`, found `(isize,)`
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct Point(int, int);
+struct Point(isize, isize);
fn main() {
let origin = Point(0, 0);
origin.1;
origin.2;
//~^ ERROR attempted out-of-bounds tuple index `2` on type `Point`
- let tuple = (0i, 0i);
+ let tuple = (0is, 0is);
tuple.0;
tuple.1;
tuple.2;
- //~^ ERROR attempted out-of-bounds tuple index `2` on type `(int, int)`
+ //~^ ERROR attempted out-of-bounds tuple index `2` on type `(isize, isize)`
}
identity_u16(y);
//~^ ERROR mismatched types: expected `u16`, found `i32`
- let a = 3i;
+ let a = 3is;
- fn identity_i(n: int) -> int { n }
+ fn identity_i(n: isize) -> int { n }
identity_i(a); // ok
identity_u16(a);
- //~^ ERROR mismatched types: expected `u16`, found `int`
+ //~^ ERROR mismatched types: expected `u16`, found `isize`
}
// Checking that the compiler reports multiple type errors at once
// error-pattern:mismatched types: expected `bool`
-// error-pattern:mismatched types: expected `int`
+// error-pattern:mismatched types: expected `isize`
-fn main() { let a: bool = 1i; let b: int = true; }
+fn main() { let a: bool = 1is; let b: isize = true; }
// ignore-tidy-linelength
use std::cell::UnsafeCell;
-use std::kinds::marker;
+use std::marker;
struct MySync<T> {
u: UnsafeCell<T>
fn main() {
let us = UnsafeCell::new(MySync{u: UnsafeCell::new(0i)});
test(us);
- //~^ ERROR `core::kinds::Sync` is not implemented
+ //~^ ERROR `core::marker::Sync` is not implemented
let uns = UnsafeCell::new(NoSync{m: marker::NoSync});
test(uns);
- //~^ ERROR `core::kinds::Sync` is not implemented
+ //~^ ERROR `core::marker::Sync` is not implemented
let ms = MySync{u: uns};
test(ms);
- //~^ ERROR `core::kinds::Sync` is not implemented
+ //~^ ERROR `core::marker::Sync` is not implemented
let ns = NoSync{m: marker::NoSync};
test(ns);
- //~^ ERROR `core::kinds::Sync` is not implemented
+ //~^ ERROR `core::marker::Sync` is not implemented
}
}
fn test1() {
- let x: Foo<_> = Bar::<uint>;
- //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar<uint>`
- let y: Foo<uint> = x;
+ let x: Foo<_> = Bar::<usize>;
+ //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar<usize>`
+ let y: Foo<usize> = x;
}
fn test2() {
- let x: Foo<_> = Bar::<uint>;
- //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar<uint>`
+ let x: Foo<_> = Bar::<usize>;
+ //~^ ERROR mismatched types: expected `Foo<_>`, found `Bar<usize>`
}
#![feature(unboxed_closures)]
#![allow(dead_code)]
-use std::kinds::marker;
+use std::marker;
trait Foo<'a,T,U> {
fn dummy(&'a self) -> &'a (T,U);
fn main() {
let i = box r { b: true };
let _j = i.clone(); //~ ERROR not implement
- println!("{}", i);
+ println!("{:?}", i);
}
fn main() {
let i = box Rc::new(100i);
f(i);
- //~^ ERROR `core::kinds::Send` is not implemented
- //~^^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
+ //~^^ ERROR `core::marker::Send` is not implemented
}
f(clone(&r1), clone(&r2));
//~^ ERROR the trait `core::clone::Clone` is not implemented for the type
//~^^ ERROR the trait `core::clone::Clone` is not implemented for the type
- println!("{}", (r2, i1.get()));
- println!("{}", (r1, i2.get()));
+ println!("{:?}", (r2, i1.get()));
+ println!("{:?}", (r1, i2.get()));
}
fn main() {
let cat = "kitty".to_string();
let (tx, _) = channel();
- //~^ ERROR `core::kinds::Send` is not implemented
- //~^^ ERROR `core::kinds::Send` is not implemented
+ //~^ ERROR `core::marker::Send` is not implemented
+ //~^^ ERROR `core::marker::Send` is not implemented
tx.send(foo(42, Rc::new(cat)));
}
// except according to those terms.
fn bar<T: Sized>() { }
-fn foo<T: ?Sized>() { bar::<T>() } //~ ERROR the trait `core::kinds::Sized` is not implemented
+fn foo<T: ?Sized>() { bar::<T>() } //~ ERROR the trait `core::marker::Sized` is not implemented
fn main() { }
enum Foo<U> { FooSome(U), FooNone }
fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::marker::Sized` is not implemented
//
// Not OK: `T` is not sized.
enum Bar<U: ?Sized> { BarSome(U), BarNone }
fn bar1<T: ?Sized>() { not_sized::<Bar<T>>() }
fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::marker::Sized` is not implemented
//
// Not OK: `Bar<T>` is not sized, but it should be.
struct Foo<T> { data: T }
fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::marker::Sized` is not implemented
//
// Not OK: `T` is not sized.
struct Bar<T: ?Sized> { data: T }
fn bar1<T: ?Sized>() { not_sized::<Bar<T>>() }
fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
-//~^ ERROR the trait `core::kinds::Sized` is not implemented
+//~^ ERROR the trait `core::marker::Sized` is not implemented
//
// Not OK: `Bar<T>` is not sized, but it should be.
}
struct S4<Y: ?Sized>;
impl<X: ?Sized> T2<X> for S4<X> {
- //~^ ERROR `core::kinds::Sized` is not implemented for the type `X`
+ //~^ ERROR `core::marker::Sized` is not implemented for the type `X`
}
fn main() { }
// Unbounded.
fn f1<X: ?Sized>(x: &X) {
f2::<X>(x);
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
fn f2<X>(x: &X) {
}
trait T {}
fn f3<X: ?Sized + T>(x: &X) {
f4::<X>(x);
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
fn f4<X: T>(x: &X) {
}
fn f6<X: ?Sized>(x: &X) {}
fn f7<X: ?Sized>(x1: &E<X>, x2: &E<X>) {
f5(x1);
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
f6(x2); // ok
}
fn f8<X: ?Sized>(x1: &S<X>, x2: &S<X>) {
f5(x1);
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
f6(x2); // ok
}
// Test some tuples.
fn f9<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) {
f5(&(*x1, 34i));
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
fn f10<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) {
f5(&(32i, *x2));
- //~^ ERROR the trait `core::kinds::Sized` is not implemented
+ //~^ ERROR the trait `core::marker::Sized` is not implemented
}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test `Sized?` types not allowed in fields (except the last one).
+// Test `?Sized` types not allowed in fields (except the last one).
struct S1<X: ?Sized> {
- f1: X, //~ ERROR `core::kinds::Sized` is not implemented
+ f1: X, //~ ERROR `core::marker::Sized` is not implemented
f2: int,
}
struct S2<X: ?Sized> {
f: int,
- g: X, //~ ERROR `core::kinds::Sized` is not implemented
+ g: X, //~ ERROR `core::marker::Sized` is not implemented
h: int,
}
struct S3 {
- f: str, //~ ERROR `core::kinds::Sized` is not implemented
+ f: str, //~ ERROR `core::marker::Sized` is not implemented
g: [uint]
}
struct S4 {
- f: str, //~ ERROR `core::kinds::Sized` is not implemented
+ f: str, //~ ERROR `core::marker::Sized` is not implemented
g: uint
}
enum E<X: ?Sized> {
- V1(X, int), //~ERROR `core::kinds::Sized` is not implemented
+ V1(X, int), //~ERROR `core::marker::Sized` is not implemented
}
enum F<X: ?Sized> {
- V2{f1: X, f: int}, //~ERROR `core::kinds::Sized` is not implemented
+ V2{f1: X, f: int}, //~ERROR `core::marker::Sized` is not implemented
}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test `Sized?` local variables.
+// Test `?Sized` local variables.
trait T {}
fn f1<X: ?Sized>(x: &X) {
let _: X; // <-- this is OK, no bindings created, no initializer.
let _: (int, (X, int)); // same
- let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented
- let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented
+ let y: X; //~ERROR the trait `core::marker::Sized` is not implemented
+ let y: (int, (X, int)); //~ERROR the trait `core::marker::Sized` is not implemented
}
fn f2<X: ?Sized + T>(x: &X) {
- let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented
- let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented
+ let y: X; //~ERROR the trait `core::marker::Sized` is not implemented
+ let y: (int, (X, int)); //~ERROR the trait `core::marker::Sized` is not implemented
}
fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
- let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented
- let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented
- let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented
+ let y: X = *x1; //~ERROR the trait `core::marker::Sized` is not implemented
+ let y = *x2; //~ERROR the trait `core::marker::Sized` is not implemented
+ let (y, z) = (*x3, 4i); //~ERROR the trait `core::marker::Sized` is not implemented
}
fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
- let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented
- let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented
- let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented
+ let y: X = *x1; //~ERROR the trait `core::marker::Sized` is not implemented
+ let y = *x2; //~ERROR the trait `core::marker::Sized` is not implemented
+ let (y, z) = (*x3, 4i); //~ERROR the trait `core::marker::Sized` is not implemented
}
-fn g1<X: ?Sized>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented
-fn g2<X: ?Sized + T>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented
+fn g1<X: ?Sized>(x: X) {} //~ERROR the trait `core::marker::Sized` is not implemented
+fn g2<X: ?Sized + T>(x: X) {} //~ERROR the trait `core::marker::Sized` is not implemented
pub fn main() {
}
}
struct S3<Y: ?Sized>;
impl<X: ?Sized + T> T1<X> for S3<X> {
- //~^ ERROR `core::kinds::Sized` is not implemented for the type `X`
+ //~^ ERROR `core::marker::Sized` is not implemented for the type `X`
}
fn main() { }
n: i64
}
-impl fmt::Show for Number {
+impl fmt::String for Number {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.n)
}
}
extern {
- fn foo(f: int, x: u8, ...);
+ fn foo(f: isize, x: u8, ...);
}
-extern "C" fn bar(f: int, x: u8) {}
+extern "C" fn bar(f: isize, x: u8) {}
fn main() {
unsafe {
foo(); //~ ERROR: this function takes at least 2 parameters but 0 parameters were supplied
foo(1); //~ ERROR: this function takes at least 2 parameters but 1 parameter was supplied
- let x: unsafe extern "C" fn(f: int, x: u8) = foo;
- //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(int, u8)`
- // , found `unsafe extern "C" fn(int, u8, ...)`
+ let x: unsafe extern "C" fn(f: isize, x: u8) = foo;
+ //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(isize, u8)`
+ // , found `unsafe extern "C" fn(isize, u8, ...)`
// (expected non-variadic fn, found variadic function)
- let y: unsafe extern "C" fn(f: int, x: u8, ...) = bar;
- //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(int, u8, ...)`
- // , found `extern "C" extern fn(int, u8)`
+ let y: unsafe extern "C" fn(f: isize, x: u8, ...) = bar;
+ //~^ ERROR: mismatched types: expected `unsafe extern "C" fn(isize, u8, ...)`
+ // , found `extern "C" extern fn(isize, u8)`
// (expected variadic fn, found non-variadic function)
foo(1, 2, 3f32); //~ ERROR: can't pass an f32 to variadic function, cast to c_double
let j = vec!(r(1));
let k = i + j;
//~^ ERROR binary operation `+` cannot be applied to type
- println!("{}", j);
+ println!("{:?}", j);
}
mod xx {
extern {
- pub fn strlen(str: *const u8) -> uint; //~ ERROR found rust type `uint`
- pub fn foo(x: int, y: uint); //~ ERROR found rust type `int`
- //~^ ERROR found rust type `uint`
+ pub fn strlen(str: *const u8) -> usize; //~ ERROR found rust type `usize`
+ pub fn foo(x: isize, y: usize); //~ ERROR found rust type `isize`
+ //~^ ERROR found rust type `usize`
}
}
fn fails_copy(self) {
require_copy(self.x);
- //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `T`
+ //~^ ERROR the trait `core::marker::Copy` is not implemented for the type `T`
}
}
fn fails_copy(self) {
require_copy(self.x);
- //~^ ERROR the trait `core::kinds::Copy` is not implemented for the type `T`
+ //~^ ERROR the trait `core::marker::Copy` is not implemented for the type `T`
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct A;
+fn equal<T>(_: &T, _: &T) -> bool where int : Eq {
+ true //~^ ERROR cannot bound type `isize`, where clause bounds may only be attached
+}
+
+// This should be fine involves a type parameter.
+fn test<T: Eq>() -> bool where Option<T> : Eq {}
+
+// This should be rejected as well.
+fn test2() -> bool where Option<int> : Eq {}
+//~^ ERROR cannot bound type `core::option::Option<isize>`, where clause bounds
-trait U {}
+#[derive(PartialEq)]
+//~^ ERROR cannot bound type `isize`, where clause bounds
+enum Foo<T> where int : Eq { MkFoo }
+//~^ ERROR cannot bound type `isize`, where clause bounds
-// impl U for A {}
+fn test3<T: Eq>() -> bool where Option<Foo<T>> : Eq {}
+
+fn test4() -> bool where Option<Foo<int>> : Eq {}
+//~^ ERROR cannot bound type `core::option::Option<Foo<isize>>`, where clause bounds
+
+trait Baz<T> where int : Eq {
+ fn baz() where String : Eq;
+}
-fn equal<T>(_: &T, _: &T) -> bool where A : U {
- true
+impl Baz<int> for int where int : Eq {
+ //~^ ERROR cannot bound type `isize`, where clause bounds
+ fn baz() where String : Eq {}
}
fn main() {
equal(&0i, &0i);
- //~^ ERROR the trait `U` is not implemented for the type `A`
}
// gdb-command:whatis 'basic-types-globals-metadata::B'
// gdb-check:type = bool
// gdb-command:whatis 'basic-types-globals-metadata::I'
-// gdb-check:type = int
+// gdb-check:type = isize
// gdb-command:whatis 'basic-types-globals-metadata::C'
// gdb-check:type = char
// gdb-command:whatis 'basic-types-globals-metadata::I8'
// gdb-command:whatis 'basic-types-globals-metadata::I64'
// gdb-check:type = i64
// gdb-command:whatis 'basic-types-globals-metadata::U'
-// gdb-check:type = uint
+// gdb-check:type = usize
// gdb-command:whatis 'basic-types-globals-metadata::U8'
// gdb-check:type = u8
// gdb-command:whatis 'basic-types-globals-metadata::U16'
// gdb-command:whatis b
// gdb-check:type = bool
// gdb-command:whatis i
-// gdb-check:type = int
+// gdb-check:type = isize
// gdb-command:whatis c
// gdb-check:type = char
// gdb-command:whatis i8
// gdb-command:whatis i64
// gdb-check:type = i64
// gdb-command:whatis u
-// gdb-check:type = uint
+// gdb-check:type = usize
// gdb-command:whatis u8
// gdb-check:type = u8
// gdb-command:whatis u16
fn main() {
let unit: () = ();
let b: bool = false;
- let i: int = -1;
+ let i: isize = -1;
let c: char = 'a';
let i8: i8 = 68;
let i16: i16 = -16;
let i32: i32 = -32;
let i64: i64 = -64;
- let u: uint = 1;
+ let u: usize = 1;
let u8: u8 = 100;
let u16: u16 = 16;
let u32: u32 = 32;
// gdb-command: print nested_variant2
// gdb-check:$16 = NestedVariant2 = {abc = NestedStruct = {regular_struct = RegularStruct = {the_first_field = 117, the_second_field = 118.5, the_third_field = false, the_fourth_field = "NestedStructString10"}, tuple_struct = TupleStruct = {119.5, 120}, empty_struct = EmptyStruct, c_style_enum = CStyleEnumVar3, mixed_enum = MixedEnumStructVar = {field1 = 121.5, field2 = -122}}}
+// gdb-command: print none_check1
+// gdb-check:$17 = None
+
+// gdb-command: print none_check2
+// gdb-check:$18 = None
+
use self::CStyleEnum::{CStyleEnumVar1, CStyleEnumVar2, CStyleEnumVar3};
use self::MixedEnum::{MixedEnumCStyleVar, MixedEnumTupleVar, MixedEnumStructVar};
use self::NestedEnum::{NestedVariant1, NestedVariant2};
}
};
+ let none_check1: Option<(uint, Vec<uint>)> = None;
+ let none_check2: Option<String> = None;
+
zzz(); // #break
}
// lldb-command:run
// lldb-command:print int_int
-// lldb-check:[...]$0 = AGenericStruct<int, int> { key: 0, value: 1 }
+// lldb-check:[...]$0 = AGenericStruct<isize, isize> { key: 0, value: 1 }
// lldb-command:print int_float
-// lldb-check:[...]$1 = AGenericStruct<int, f64> { key: 2, value: 3.5 }
+// lldb-check:[...]$1 = AGenericStruct<isize, f64> { key: 2, value: 3.5 }
// lldb-command:print float_int
-// lldb-check:[...]$2 = AGenericStruct<f64, int> { key: 4.5, value: 5 }
+// lldb-check:[...]$2 = AGenericStruct<f64, isize> { key: 4.5, value: 5 }
// lldb-command:print float_int_float
-// lldb-check:[...]$3 = AGenericStruct<f64, generic-struct::AGenericStruct<int, f64>> { key: 6.5, value: AGenericStruct<int, f64> { key: 7, value: 8.5 } }
+// lldb-check:[...]$3 = AGenericStruct<f64, generic-struct::AGenericStruct<isize, f64>> { key: 6.5, value: AGenericStruct<isize, f64> { key: 7, value: 8.5 } }
#![omit_gdb_pretty_printer_section]
// gdb-check:$3 = {RUST$ENCODED$ENUM$1$Empty = {454545, 0x87654321, 9988}}
// gdb-command:print empty_gdb->discr
-// gdb-check:$4 = (int *) 0x0
+// gdb-check:$4 = (isize *) 0x0
// gdb-command:print droid
// gdb-check:$5 = {RUST$ENCODED$ENUM$2$Void = {id = 675675, range = 10000001, internals = 0x43218765}}
// gdb-command:print void_droid_gdb->internals
-// gdb-check:$6 = (int *) 0x0
+// gdb-check:$6 = (isize *) 0x0
// gdb-command:continue
// this case (by casting the value to a memory-equivalent struct).
enum MoreFields<'a> {
- Full(u32, &'a int, i16),
+ Full(u32, &'a isize, i16),
Empty
}
struct MoreFieldsRepr<'a> {
a: u32,
- discr: &'a int,
+ discr: &'a isize,
b: i16
}
enum NamedFields<'a> {
- Droid { id: i32, range: i64, internals: &'a int },
+ Droid { id: i32, range: i64, internals: &'a isize },
Void
}
struct NamedFieldsRepr<'a> {
id: i32,
range: i64,
- internals: &'a int
+ internals: &'a isize
}
fn main() {
// gdb-check:type = struct GenericStruct<type-names::Mod1::Struct2, type-names::Mod1::Mod2::Struct3>
// gdb-command:whatis generic_struct2
-// gdb-check:type = struct GenericStruct<type-names::Struct1, extern "fastcall" fn(int) -> uint>
+// gdb-check:type = struct GenericStruct<type-names::Struct1, extern "fastcall" fn(isize) -> usize>
// gdb-command:whatis mod_struct
// gdb-check:type = struct Struct2
// RAW POINTERS
// gdb-command:whatis mut_ptr1
-// gdb-check:type = struct (*mut type-names::Struct1, int)
+// gdb-check:type = struct (*mut type-names::Struct1, isize)
// gdb-command:whatis mut_ptr2
-// gdb-check:type = struct (*mut int, int)
+// gdb-check:type = struct (*mut isize, isize)
// gdb-command:whatis mut_ptr3
-// gdb-check:type = struct (*mut type-names::Mod1::Mod2::Enum3<type-names::Struct1>, int)
+// gdb-check:type = struct (*mut type-names::Mod1::Mod2::Enum3<type-names::Struct1>, isize)
// gdb-command:whatis const_ptr1
-// gdb-check:type = struct (*const type-names::Struct1, int)
+// gdb-check:type = struct (*const type-names::Struct1, isize)
// gdb-command:whatis const_ptr2
-// gdb-check:type = struct (*const int, int)
+// gdb-check:type = struct (*const isize, isize)
// gdb-command:whatis const_ptr3
-// gdb-check:type = struct (*const type-names::Mod1::Mod2::Enum3<type-names::Struct1>, int)
+// gdb-check:type = struct (*const type-names::Mod1::Mod2::Enum3<type-names::Struct1>, isize)
// VECTORS
// gdb-check:type = struct ([type-names::Struct1; 3], i16)
// gdb-command:whatis fixed_size_vec2
-// gdb-check:type = struct ([uint; 3], i16)
+// gdb-check:type = struct ([usize; 3], i16)
// gdb-command:whatis slice1
-// gdb-check:type = struct &[uint]
+// gdb-check:type = struct &[usize]
// gdb-command:whatis slice2
// gdb-check:type = struct &[type-names::Mod1::Enum2]
// gdb-check:type = struct &Trait2<type-names::Struct1, type-names::Struct1>
// gdb-command:whatis generic_mut_ref_trait
-// gdb-check:type = struct &mut Trait2<type-names::Mod1::Mod2::Struct3, type-names::GenericStruct<uint, int>>
+// gdb-check:type = struct &mut Trait2<type-names::Mod1::Mod2::Struct3, type-names::GenericStruct<usize, isize>>
// BARE FUNCTIONS
// gdb-command:whatis rust_fn
-// gdb-check:type = struct (fn(core::option::Option<int>, core::option::Option<&type-names::Mod1::Struct2>), uint)
+// gdb-check:type = struct (fn(core::option::Option<isize>, core::option::Option<&type-names::Mod1::Struct2>), usize)
// gdb-command:whatis extern_c_fn
-// gdb-check:type = struct (extern "C" fn(int), uint)
+// gdb-check:type = struct (extern "C" fn(isize), usize)
// gdb-command:whatis unsafe_fn
-// gdb-check:type = struct (unsafe fn(core::result::Result<char, f64>), uint)
+// gdb-check:type = struct (unsafe fn(core::result::Result<char, f64>), usize)
// gdb-command:whatis extern_stdcall_fn
-// gdb-check:type = struct (extern "stdcall" fn(), uint)
+// gdb-check:type = struct (extern "stdcall" fn(), usize)
// gdb-command:whatis rust_fn_with_return_value
-// gdb-check:type = struct (fn(f64) -> uint, uint)
+// gdb-check:type = struct (fn(f64) -> usize, usize)
// gdb-command:whatis extern_c_fn_with_return_value
-// gdb-check:type = struct (extern "C" fn() -> type-names::Struct1, uint)
+// gdb-check:type = struct (extern "C" fn() -> type-names::Struct1, usize)
// gdb-command:whatis unsafe_fn_with_return_value
-// gdb-check:type = struct (unsafe fn(type-names::GenericStruct<u16, u8>) -> type-names::Mod1::Struct2, uint)
+// gdb-check:type = struct (unsafe fn(type-names::GenericStruct<u16, u8>) -> type-names::Mod1::Struct2, usize)
// gdb-command:whatis extern_stdcall_fn_with_return_value
-// gdb-check:type = struct (extern "stdcall" fn(Box<int>) -> uint, uint)
+// gdb-check:type = struct (extern "stdcall" fn(Box<isize>) -> usize, usize)
// gdb-command:whatis generic_function_int
-// gdb-check:type = struct (fn(int) -> int, uint)
+// gdb-check:type = struct (fn(isize) -> isize, usize)
// gdb-command:whatis generic_function_struct3
-// gdb-check:type = struct (fn(type-names::Mod1::Mod2::Struct3) -> type-names::Mod1::Mod2::Struct3, uint)
+// gdb-check:type = struct (fn(type-names::Mod1::Mod2::Struct3) -> type-names::Mod1::Mod2::Struct3, usize)
// gdb-command:whatis variadic_function
-// gdb-check:type = struct (unsafe extern "C" fn(*const u8, ...) -> int, uint)
+// gdb-check:type = struct (unsafe extern "C" fn(*const u8, ...) -> isize, usize)
// CLOSURES
// gdb-command:whatis closure1
-// gdb-check:type = struct (closure, uint)
+// gdb-check:type = struct (closure, usize)
// gdb-command:whatis closure2
-// gdb-check:type = struct (closure, uint)
+// gdb-check:type = struct (closure, usize)
#![omit_gdb_pretty_printer_section]
enum Enum1 {
Variant1_1,
- Variant1_2(int)
+ Variant1_2(isize)
}
mod Mod1 {
trait Trait1 { }
trait Trait2<T1, T2> { }
-impl Trait1 for int {}
-impl<T1, T2> Trait2<T1, T2> for int {}
+impl Trait1 for isize {}
+impl<T1, T2> Trait2<T1, T2> for isize {}
-fn rust_fn(_: Option<int>, _: Option<&Mod1::Struct2>) {}
-extern "C" fn extern_c_fn(_: int) {}
+fn rust_fn(_: Option<isize>, _: Option<&Mod1::Struct2>) {}
+extern "C" fn extern_c_fn(_: isize) {}
unsafe fn unsafe_fn(_: Result<char, f64>) {}
extern "stdcall" fn extern_stdcall_fn() {}
-fn rust_fn_with_return_value(_: f64) -> uint { 4 }
+fn rust_fn_with_return_value(_: f64) -> usize { 4 }
extern "C" fn extern_c_fn_with_return_value() -> Struct1 { Struct1 }
unsafe fn unsafe_fn_with_return_value(_: GenericStruct<u16, u8>) -> Mod1::Struct2 { Mod1::Struct2 }
-extern "stdcall" fn extern_stdcall_fn_with_return_value(_: Box<int>) -> uint { 0 }
+extern "stdcall" fn extern_stdcall_fn_with_return_value(_: Box<isize>) -> usize { 0 }
fn generic_function<T>(x: T) -> T { x }
extern {
- fn printf(_:*const u8, ...) -> int;
+ fn printf(_:*const u8, ...) -> isize;
}
// In many of the cases below, the type that is actually under test is wrapped
// Structs
let simple_struct = Struct1;
let generic_struct1: GenericStruct<Mod1::Struct2, Mod1::Mod2::Struct3> = GenericStruct;
- let generic_struct2: GenericStruct<Struct1, extern "fastcall" fn(int) -> uint> = GenericStruct;
+ let generic_struct2: GenericStruct<Struct1, extern "fastcall" fn(isize) -> usize> = GenericStruct;
let mod_struct = Mod1::Struct2;
// Enums
let mut_ref2 = (&mut mut_generic_struct, 0i32);
// Raw Pointers
- let mut_ptr1: (*mut Struct1, int) = (ptr::null_mut(), 0);
- let mut_ptr2: (*mut int, int) = (ptr::null_mut(), 0);
- let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, int) = (ptr::null_mut(), 0);
+ let mut_ptr1: (*mut Struct1, isize) = (ptr::null_mut(), 0);
+ let mut_ptr2: (*mut isize, isize) = (ptr::null_mut(), 0);
+ let mut_ptr3: (*mut Mod1::Mod2::Enum3<Struct1>, isize) = (ptr::null_mut(), 0);
- let const_ptr1: (*const Struct1, int) = (ptr::null(), 0);
- let const_ptr2: (*const int, int) = (ptr::null(), 0);
- let const_ptr3: (*const Mod1::Mod2::Enum3<Struct1>, int) = (ptr::null(), 0);
+ let const_ptr1: (*const Struct1, isize) = (ptr::null(), 0);
+ let const_ptr2: (*const isize, isize) = (ptr::null(), 0);
+ let const_ptr3: (*const Mod1::Mod2::Enum3<Struct1>, isize) = (ptr::null(), 0);
// Vectors
let fixed_size_vec1 = ([Struct1, Struct1, Struct1], 0i16);
let mut generic_mut_ref_trait_impl = 0i;
let generic_mut_ref_trait = (&mut generic_mut_ref_trait_impl) as
- &mut Trait2<Mod1::Mod2::Struct3, GenericStruct<uint, int>>;
+ &mut Trait2<Mod1::Mod2::Struct3, GenericStruct<usize, isize>>;
// Bare Functions
let rust_fn = (rust_fn, 0u);
let unsafe_fn_with_return_value = (unsafe_fn_with_return_value, 0u);
let extern_stdcall_fn_with_return_value = (extern_stdcall_fn_with_return_value, 0u);
- let generic_function_int = (generic_function::<int>, 0u);
+ let generic_function_int = (generic_function::<isize>, 0u);
let generic_function_struct3 = (generic_function::<Mod1::Mod2::Struct3>, 0u);
let variadic_function = (printf, 0u);
// how that maps to rustc's internal representation of these forms.
// Once closures have reached their 1.0 form, the tests below should
// probably be expanded.
- let closure1 = (|&: x:int| {}, 0u);
+ let closure1 = (|&: x:isize| {}, 0u);
let closure2 = (|&: x:i8, y: f32| { (x as f32) + y }, 0u);
zzz(); // #break
let empty: &[i64] = &[];
let singleton: &[i64] = &[1];
let multiple: &[i64] = &[2, 3, 4, 5];
- let slice_of_slice = multiple[1..3];
+ let slice_of_slice = &multiple[1..3];
let padded_tuple: &[(i32, i16)] = &[(6, 7), (8, 9)];
// #4264 fixed-length vector types
-pub fn foo(_: [int; (3 as uint)]) { }
+pub fn foo(_: [isize; (3 as usize)]) { }
pub fn bar() {
- const FOO: uint = ((5u as uint) - (4u as uint) as uint);
- let _: [(); (FOO as uint)] = ([(() as ())] as [(); 1]);
+ const FOO: usize = ((5us as usize) - (4us as usize) as usize);
+ let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
- let _: [(); (1u as uint)] = ([(() as ())] as [(); 1]);
+ let _: [(); (1us as usize)] = ([(() as ())] as [(); 1]);
let _ =
- (((&((([(1i as int), (2 as int), (3 as int)] as [int; 3])) as
- [int; 3]) as &[int; 3]) as *const _ as *const [int; 3]) as
- *const [int; (3u as uint)] as *const [int; 3]);
+ (((&((([(1is as isize), (2 as isize), (3 as isize)] as [isize; 3])) as
+ [isize; 3]) as &[isize; 3]) as *const _ as *const [isize; 3])
+ as *const [isize; (3us as usize)] as *const [isize; 3]);
core::fmt::Arguments<'_>))
as collections::string::String);
}
-pub type Foo = [int; (3u as uint)];
+pub type Foo = [isize; (3us as usize)];
pub struct Bar {
- pub x: [int; (3u as uint)],
+ pub x: [isize; (3us as usize)],
}
-pub struct TupleBar([int; (4u as uint)]);
-pub enum Baz { BazVariant([int; (5u as uint)]), }
+pub struct TupleBar([isize; (4us as usize)]);
+pub enum Baz { BazVariant([isize; (5us as usize)]), }
pub fn id<T>(x: T) -> T { (x as T) }
pub fn use_id() {
let _ =
- ((id::<[int; (3u as uint)]> as
- fn([int; 3]) -> [int; 3] {id})(([(1 as int), (2 as int),
- (3 as int)] as [int; 3])) as
- [int; 3]);
+ ((id::<[isize; (3us as usize)]> as
+ fn([isize; 3]) -> [isize; 3] {id})(([(1 as isize), (2 as isize),
+ (3 as isize)] as
+ [isize; 3])) as
+ [isize; 3]);
}
fn main() { }
// #4264 fixed-length vector types
-pub fn foo(_: [int; 3]) {}
+pub fn foo(_: [isize; 3]) {}
pub fn bar() {
- const FOO: uint = 5u - 4u;
+ const FOO: usize = 5us - 4us;
let _: [(); FOO] = [()];
- let _ : [(); 1u] = [()];
+ let _ : [(); 1us] = [()];
- let _ = &([1i,2,3]) as *const _ as *const [int; 3u];
+ let _ = &([1is,2,3]) as *const _ as *const [isize; 3us];
format!("test");
}
-pub type Foo = [int; 3u];
+pub type Foo = [isize; 3us];
pub struct Bar {
- pub x: [int; 3u]
+ pub x: [isize; 3us]
}
-pub struct TupleBar([int; 4u]);
+pub struct TupleBar([isize; 4us]);
pub enum Baz {
- BazVariant([int; 5u])
+ BazVariant([isize; 5us])
}
pub fn id<T>(x: T) -> T { x }
pub fn use_id() {
- let _ = id::<[int; 3u]>([1,2,3]);
+ let _ = id::<[isize; 3us]>([1,2,3]);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:assertion failed: 1i == 2
+// error-pattern:assertion failed: 1is == 2
fn main() {
- assert!(1i == 2);
+ assert!(1is == 2);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:assertion failed: `(left == right) && (right == left)` (left: `14`, right: `15`)
+// error-pattern:assertion failed: `(left == right) && (right == left)` (left: `14i`, right: `15i`)
fn main() {
assert_eq!(14i,15i);
use std::thread::Thread;
fn main() {
- let r: Result<int,_> = Thread::spawn(move|| {
+ let r: Result<int,_> = Thread::scoped(move|| {
panic!("test");
1i
}).join();
use std::thread::Builder;
fn main() {
- let r: Result<int,_> = Builder::new().name("owned name".to_string()).spawn(move|| {
+ let r: Result<int,_> = Builder::new().name("owned name".to_string()).scoped(move|| {
panic!("test");
1i
}).join();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
-
-// error-pattern:1i == 2
-fn main() { assert!((1i == 2)); }
+// error-pattern:1is == 2
+fn main() { assert!((1is == 2)); }
fn main() {
// the purpose of this test is to make sure that task::spawn()
// works when provided with a bare function:
- let r = Thread::spawn(startfn).join();
+ let r = Thread::scoped(startfn).join();
if r.is_err() {
panic!()
}
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 1i"];
- N3[label="stmt 1i;"];
- N4[label="block { 1i; }"];
+ N2[label="expr 1is"];
+ N3[label="stmt 1is;"];
+ N4[label="block { 1is; }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 3i"];
+ N2[label="expr 3is"];
N3[label="expr 4"];
- N4[label="expr 3i + 4"];
- N5[label="stmt 3i + 4;"];
- N6[label="block { 3i + 4; }"];
+ N4[label="expr 3is + 4"];
+ N5[label="stmt 3is + 4;"];
+ N6[label="block { 3is + 4; }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 4i"];
+ N2[label="expr 4is"];
N3[label="local _x"];
- N4[label="stmt let _x = 4i;"];
- N5[label="block { let _x = 4i; }"];
+ N4[label="stmt let _x = 4is;"];
+ N5[label="block { let _x = 4is; }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 5i"];
- N3[label="expr 55i"];
- N4[label="expr (5i, 55i)"];
+ N2[label="expr 5is"];
+ N3[label="expr 55is"];
+ N4[label="expr (5is, 55is)"];
N5[label="local _x"];
N6[label="local _y"];
N7[label="pat (_x, _y)"];
- N8[label="stmt let (_x, _y) = (5i, 55i);"];
- N9[label="block { let (_x, _y) = (5i, 55i); }"];
+ N8[label="stmt let (_x, _y) = (5is, 55is);"];
+ N9[label="block { let (_x, _y) = (5is, 55is); }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 7i"];
- N3[label="expr 77i"];
- N4[label="expr 777i"];
- N5[label="expr 7777i"];
- N6[label="expr [7i, 77i, 777i, 7777i]"];
- N7[label="expr match [7i, 77i, 777i, 7777i] { [x, y, ..] => x + y, }"];
+ N2[label="expr 7is"];
+ N3[label="expr 77is"];
+ N4[label="expr 777is"];
+ N5[label="expr 7777is"];
+ N6[label="expr [7is, 77is, 777is, 7777is]"];
+ N7[label="expr match [7is, 77is, 777is, 7777is] { [x, y, ..] => x + y, }"];
N8[label="(dummy_node)"];
N9[label="local x"];
N10[label="local y"];
N13[label="expr x"];
N14[label="expr y"];
N15[label="expr x + y"];
- N16[label="stmt match [7i, 77i, 777i, 7777i] { [x, y, ..] => x + y, };"];
- N17[label="block { match [7i, 77i, 777i, 7777i] { [x, y, ..] => x + y, }; }"];
+ N16[label="stmt match [7is, 77is, 777is, 7777is] { [x, y, ..] => x + y, };"];
+ N17[label="block { match [7is, 77is, 777is, 7777is] { [x, y, ..] => x + y, }; }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 8i"];
+ N2[label="expr 8is"];
N3[label="local x"];
- N4[label="stmt let x = 8i;"];
+ N4[label="stmt let x = 8is;"];
N5[label="local _y"];
N6[label="stmt let _y;"];
N7[label="expr x"];
- N8[label="expr 88i"];
- N9[label="expr x > 88i"];
- N10[label="expr 888i"];
+ N8[label="expr 88is"];
+ N9[label="expr x > 88is"];
+ N10[label="expr 888is"];
N11[label="expr _y"];
- N12[label="expr _y = 888i"];
- N13[label="stmt _y = 888i;"];
- N14[label="block { _y = 888i; }"];
- N15[label="expr if x > 88i { _y = 888i; }"];
- N16[label="block { let x = 8i; let _y; if x > 88i { _y = 888i; } }"];
+ N12[label="expr _y = 888is"];
+ N13[label="stmt _y = 888is;"];
+ N14[label="block { _y = 888is; }"];
+ N15[label="expr if x > 88is { _y = 888is; }"];
+ N16[label="block { let x = 8is; let _y; if x > 88is { _y = 888is; } }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 91i"];
+ N2[label="expr 91is"];
N3[label="local x"];
- N4[label="stmt let x = 91i;"];
+ N4[label="stmt let x = 91is;"];
N5[label="local _y"];
N6[label="stmt let _y;"];
N7[label="expr x"];
- N8[label="expr 92i"];
- N9[label="expr x > 92i"];
- N10[label="expr 93i"];
+ N8[label="expr 92is"];
+ N9[label="expr x > 92is"];
+ N10[label="expr 93is"];
N11[label="expr _y"];
- N12[label="expr _y = 93i"];
- N13[label="stmt _y = 93i;"];
- N14[label="block { _y = 93i; }"];
- N15[label="expr 94i"];
- N16[label="expr 95i"];
- N17[label="expr 94i + 95i"];
+ N12[label="expr _y = 93is"];
+ N13[label="stmt _y = 93is;"];
+ N14[label="block { _y = 93is; }"];
+ N15[label="expr 94is"];
+ N16[label="expr 95is"];
+ N17[label="expr 94is + 95is"];
N18[label="expr _y"];
- N19[label="expr _y = 94i + 95i"];
- N20[label="stmt _y = 94i + 95i;"];
- N21[label="block { _y = 94i + 95i; }"];
- N22[label="expr { _y = 94i + 95i; }"];
- N23[label="expr if x > 92i { _y = 93i; } else { _y = 94i + 95i; }"];
- N24[label="block { let x = 91i; let _y; if x > 92i { _y = 93i; } else { _y = 94i + 95i; } }"];
+ N19[label="expr _y = 94is + 95is"];
+ N20[label="stmt _y = 94is + 95is;"];
+ N21[label="block { _y = 94is + 95is; }"];
+ N22[label="expr { _y = 94is + 95is; }"];
+ N23[label="expr if x > 92is { _y = 93is; } else { _y = 94is + 95is; }"];
+ N24[label="block {\l let x = 91is;\l let _y;\l if x > 92is { _y = 93is; } else { _y = 94is + 95is; }\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
// except according to those terms.
pub fn expr_if_twoarm_9() {
- let x = 91i; let _y;
- if x > 92i {
- _y = 93i;
+ let x = 91is; let _y;
+ if x > 92is {
+ _y = 93is;
} else {
- _y = 94i+95i;
+ _y = 94is+95is;
}
}
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 10i"];
+ N2[label="expr 10is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 10i;"];
+ N4[label="stmt let mut x = 10is;"];
N5[label="(dummy_node)"];
N6[label="expr x"];
- N7[label="expr 0i"];
- N8[label="expr x > 0i"];
- N9[label="expr while x > 0i { x -= 1i; }"];
- N10[label="expr 1i"];
+ N7[label="expr 0is"];
+ N8[label="expr x > 0is"];
+ N9[label="expr while x > 0is { x -= 1is; }"];
+ N10[label="expr 1is"];
N11[label="expr x"];
- N12[label="expr x -= 1i"];
- N13[label="stmt x -= 1i;"];
- N14[label="block { x -= 1i; }"];
- N15[label="block { let mut x = 10i; while x > 0i { x -= 1i; } }"];
+ N12[label="expr x -= 1is"];
+ N13[label="stmt x -= 1is;"];
+ N14[label="block { x -= 1is; }"];
+ N15[label="block { let mut x = 10is; while x > 0is { x -= 1is; } }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 11i"];
+ N2[label="expr 11is"];
N3[label="local mut _x"];
- N4[label="stmt let mut _x = 11i;"];
+ N4[label="stmt let mut _x = 11is;"];
N5[label="(dummy_node)"];
- N6[label="expr loop { _x -= 1i; }"];
- N7[label="expr 1i"];
+ N6[label="expr loop { _x -= 1is; }"];
+ N7[label="expr 1is"];
N8[label="expr _x"];
- N9[label="expr _x -= 1i"];
- N10[label="stmt _x -= 1i;"];
- N11[label="block { _x -= 1i; }"];
- N12[label="stmt loop { _x -= 1i; }"];
+ N9[label="expr _x -= 1is"];
+ N10[label="stmt _x -= 1is;"];
+ N11[label="block { _x -= 1is; }"];
+ N12[label="stmt loop { _x -= 1is; }"];
N13[label="expr \"unreachable\""];
N14[label="stmt \"unreachable\";"];
- N15[label="block { let mut _x = 11i; loop { _x -= 1i; } \"unreachable\"; }"];
+ N15[label="block { let mut _x = 11is; loop { _x -= 1is; } \"unreachable\"; }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 12i"];
+ N2[label="expr 12is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 12i;"];
+ N4[label="stmt let mut x = 12is;"];
N5[label="(dummy_node)"];
- N6[label="expr loop { x -= 1i; if x == 2i { break ; \"unreachable\"; } }"];
- N7[label="expr 1i"];
+ N6[label="expr loop { x -= 1is; if x == 2is { break ; \"unreachable\"; } }"];
+ N7[label="expr 1is"];
N8[label="expr x"];
- N9[label="expr x -= 1i"];
- N10[label="stmt x -= 1i;"];
+ N9[label="expr x -= 1is"];
+ N10[label="stmt x -= 1is;"];
N11[label="expr x"];
- N12[label="expr 2i"];
- N13[label="expr x == 2i"];
+ N12[label="expr 2is"];
+ N13[label="expr x == 2is"];
N14[label="expr break"];
N15[label="(dummy_node)"];
N16[label="stmt break ;"];
N17[label="expr \"unreachable\""];
N18[label="stmt \"unreachable\";"];
N19[label="block { break ; \"unreachable\"; }"];
- N20[label="expr if x == 2i { break ; \"unreachable\"; }"];
- N21[label="block { x -= 1i; if x == 2i { break ; \"unreachable\"; } }"];
- N22[label="block { let mut x = 12i; loop { x -= 1i; if x == 2i { break ; \"unreachable\"; } } }"];
+ N20[label="expr if x == 2is { break ; \"unreachable\"; }"];
+ N21[label="block { x -= 1is; if x == 2is { break ; \"unreachable\"; } }"];
+ N22[label="block {\l let mut x = 12is;\l loop { x -= 1is; if x == 2is { break ; \"unreachable\"; } }\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N11 -> N12;
N12 -> N13;
N13 -> N14;
- N14 -> N6[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 2i { break ; \"unreachable\"; },\lexiting scope_4 block { x -= 1i; if x == 2i { break ; \"unreachable\"; } }"];
+ N14 -> N6[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 2is { break ; \"unreachable\"; },\lexiting scope_4 block { x -= 1is; if x == 2is { break ; \"unreachable\"; } }"];
N15 -> N16;
N16 -> N17;
N17 -> N18;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 14i"];
+ N2[label="expr 14is"];
N3[label="local x"];
- N4[label="stmt let x = 14i;"];
+ N4[label="stmt let x = 14is;"];
N5[label="expr x"];
- N6[label="expr 1i"];
- N7[label="expr x > 1i"];
+ N6[label="expr 1is"];
+ N7[label="expr x > 1is"];
N8[label="expr return"];
N9[label="(dummy_node)"];
N10[label="stmt return;"];
N11[label="expr \"unreachable\""];
N12[label="stmt \"unreachable\";"];
N13[label="block { return; \"unreachable\"; }"];
- N14[label="expr if x > 1i { return; \"unreachable\"; }"];
- N15[label="block { let x = 14i; if x > 1i { return; \"unreachable\"; } }"];
+ N14[label="expr if x > 1is { return; \"unreachable\"; }"];
+ N15[label="block { let x = 14is; if x > 1is { return; \"unreachable\"; } }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 15i"];
+ N2[label="expr 15is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 15i;"];
- N5[label="expr 151i"];
+ N4[label="stmt let mut x = 15is;"];
+ N5[label="expr 151is"];
N6[label="local mut y"];
- N7[label="stmt let mut y = 151i;"];
+ N7[label="stmt let mut y = 151is;"];
N8[label="(dummy_node)"];
- N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l }\l"];
+ N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l }\l"];
N10[label="(dummy_node)"];
- N11[label="expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l"];
+ N11[label="expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l"];
N12[label="expr x"];
- N13[label="expr 1i"];
- N14[label="expr x == 1i"];
+ N13[label="expr 1is"];
+ N14[label="expr x == 1is"];
N15[label="expr break \'outer"];
N16[label="(dummy_node)"];
N17[label="stmt break \'outer ;"];
N18[label="expr \"unreachable\""];
N19[label="stmt \"unreachable\";"];
N20[label="block { break \'outer ; \"unreachable\"; }"];
- N21[label="expr if x == 1i { break \'outer ; \"unreachable\"; }"];
- N22[label="stmt if x == 1i { break \'outer ; \"unreachable\"; }"];
+ N21[label="expr if x == 1is { break \'outer ; \"unreachable\"; }"];
+ N22[label="stmt if x == 1is { break \'outer ; \"unreachable\"; }"];
N23[label="expr y"];
- N24[label="expr 2i"];
- N25[label="expr y >= 2i"];
+ N24[label="expr 2is"];
+ N25[label="expr y >= 2is"];
N26[label="expr break"];
N27[label="(dummy_node)"];
N28[label="stmt break ;"];
N29[label="expr \"unreachable\""];
N30[label="stmt \"unreachable\";"];
N31[label="block { break ; \"unreachable\"; }"];
- N32[label="expr if y >= 2i { break ; \"unreachable\"; }"];
- N33[label="stmt if y >= 2i { break ; \"unreachable\"; }"];
- N34[label="expr 3i"];
+ N32[label="expr if y >= 2is { break ; \"unreachable\"; }"];
+ N33[label="stmt if y >= 2is { break ; \"unreachable\"; }"];
+ N34[label="expr 3is"];
N35[label="expr y"];
- N36[label="expr y -= 3i"];
- N37[label="stmt y -= 3i;"];
- N38[label="block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l}\l"];
- N39[label="stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l"];
- N40[label="expr 4i"];
+ N36[label="expr y -= 3is"];
+ N37[label="stmt y -= 3is;"];
+ N38[label="block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l}\l"];
+ N39[label="stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l"];
+ N40[label="expr 4is"];
N41[label="expr y"];
- N42[label="expr y -= 4i"];
- N43[label="stmt y -= 4i;"];
- N44[label="expr 5i"];
+ N42[label="expr y -= 4is"];
+ N43[label="stmt y -= 4is;"];
+ N44[label="expr 5is"];
N45[label="expr x"];
- N46[label="expr x -= 5i"];
- N47[label="stmt x -= 5i;"];
- N48[label="block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l}\l"];
- N49[label="block {\l let mut x = 15i;\l let mut y = 151i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l }\l}\l"];
+ N46[label="expr x -= 5is"];
+ N47[label="stmt x -= 5is;"];
+ N48[label="block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l}\l"];
+ N49[label="block {\l let mut x = 15is;\l let mut y = 151is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l }\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N12 -> N13;
N13 -> N14;
N14 -> N15;
- N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l }\l y -= 4i;\l x -= 5i;\l}\l"];
+ N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l }\l y -= 4is;\l x -= 5is;\l}\l"];
N16 -> N17;
N17 -> N18;
N18 -> N19;
N23 -> N24;
N24 -> N25;
N25 -> N26;
- N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 2i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 2i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { break ; \"unreachable\"; }\l y -= 3i;\l}\l"];
+ N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 2is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 2is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { break ; \"unreachable\"; }\l y -= 3is;\l}\l"];
N27 -> N28;
N28 -> N29;
N29 -> N30;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 16i"];
+ N2[label="expr 16is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 16i;"];
- N5[label="expr 16i"];
+ N4[label="stmt let mut x = 16is;"];
+ N5[label="expr 16is"];
N6[label="local mut y"];
- N7[label="stmt let mut y = 16i;"];
+ N7[label="stmt let mut y = 16is;"];
N8[label="(dummy_node)"];
- N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l }\l"];
+ N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l }\l"];
N10[label="(dummy_node)"];
- N11[label="expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l"];
+ N11[label="expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l"];
N12[label="expr x"];
- N13[label="expr 1i"];
- N14[label="expr x == 1i"];
+ N13[label="expr 1is"];
+ N14[label="expr x == 1is"];
N15[label="expr continue \'outer"];
N16[label="(dummy_node)"];
N17[label="stmt continue \'outer ;"];
N18[label="expr \"unreachable\""];
N19[label="stmt \"unreachable\";"];
N20[label="block { continue \'outer ; \"unreachable\"; }"];
- N21[label="expr if x == 1i { continue \'outer ; \"unreachable\"; }"];
- N22[label="stmt if x == 1i { continue \'outer ; \"unreachable\"; }"];
+ N21[label="expr if x == 1is { continue \'outer ; \"unreachable\"; }"];
+ N22[label="stmt if x == 1is { continue \'outer ; \"unreachable\"; }"];
N23[label="expr y"];
- N24[label="expr 1i"];
- N25[label="expr y >= 1i"];
+ N24[label="expr 1is"];
+ N25[label="expr y >= 1is"];
N26[label="expr break"];
N27[label="(dummy_node)"];
N28[label="stmt break ;"];
N29[label="expr \"unreachable\""];
N30[label="stmt \"unreachable\";"];
N31[label="block { break ; \"unreachable\"; }"];
- N32[label="expr if y >= 1i { break ; \"unreachable\"; }"];
- N33[label="stmt if y >= 1i { break ; \"unreachable\"; }"];
- N34[label="expr 1i"];
+ N32[label="expr if y >= 1is { break ; \"unreachable\"; }"];
+ N33[label="stmt if y >= 1is { break ; \"unreachable\"; }"];
+ N34[label="expr 1is"];
N35[label="expr y"];
- N36[label="expr y -= 1i"];
- N37[label="stmt y -= 1i;"];
- N38[label="block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l}\l"];
- N39[label="stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l"];
- N40[label="expr 1i"];
+ N36[label="expr y -= 1is"];
+ N37[label="stmt y -= 1is;"];
+ N38[label="block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l}\l"];
+ N39[label="stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l"];
+ N40[label="expr 1is"];
N41[label="expr y"];
- N42[label="expr y -= 1i"];
- N43[label="stmt y -= 1i;"];
- N44[label="expr 1i"];
+ N42[label="expr y -= 1is"];
+ N43[label="stmt y -= 1is;"];
+ N44[label="expr 1is"];
N45[label="expr x"];
- N46[label="expr x -= 1i"];
- N47[label="stmt x -= 1i;"];
- N48[label="block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l}\l"];
- N49[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l }\l"];
+ N46[label="expr x -= 1is"];
+ N47[label="stmt x -= 1is;"];
+ N48[label="block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l}\l"];
+ N49[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l }\l"];
N50[label="expr \"unreachable\""];
N51[label="stmt \"unreachable\";"];
- N52[label="block {\l let mut x = 16i;\l let mut y = 16i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l }\l \"unreachable\";\l}\l"];
+ N52[label="block {\l let mut x = 16is;\l let mut y = 16is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l }\l \"unreachable\";\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N12 -> N13;
N13 -> N14;
N14 -> N15;
- N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l }\l y -= 1i;\l x -= 1i;\l}\l"];
+ N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l }\l y -= 1is;\l x -= 1is;\l}\l"];
N16 -> N17;
N17 -> N18;
N18 -> N19;
N23 -> N24;
N24 -> N25;
N25 -> N26;
- N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 1i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 1i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 1i { break ; \"unreachable\"; }\l y -= 1i;\l}\l"];
+ N26 -> N11[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y >= 1is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y >= 1is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 1is { break ; \"unreachable\"; }\l y -= 1is;\l}\l"];
N27 -> N28;
N28 -> N29;
N29 -> N30;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 1i"];
- N3[label="expr 7i"];
- N4[label="expr 17i"];
- N5[label="expr [1i, 7i, 17i]"];
+ N2[label="expr 1is"];
+ N3[label="expr 7is"];
+ N4[label="expr 17is"];
+ N5[label="expr [1is, 7is, 17is]"];
N6[label="local _v"];
- N7[label="stmt let _v = [1i, 7i, 17i];"];
- N8[label="block { let _v = [1i, 7i, 17i]; }"];
+ N7[label="stmt let _v = [1is, 7is, 17is];"];
+ N8[label="block { let _v = [1is, 7is, 17is]; }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 2u"];
- N3[label="expr 0u"];
- N4[label="expr 20u"];
- N5[label="expr [2u, 0u, 20u]"];
+ N2[label="expr 2us"];
+ N3[label="expr 0us"];
+ N4[label="expr 20us"];
+ N5[label="expr [2us, 0us, 20us]"];
N6[label="local v"];
- N7[label="stmt let v = [2u, 0u, 20u];"];
+ N7[label="stmt let v = [2us, 0us, 20us];"];
N8[label="expr v"];
- N9[label="expr 20u"];
- N10[label="expr v[20u]"];
- N11[label="stmt v[20u];"];
- N12[label="block { let v = [2u, 0u, 20u]; v[20u]; }"];
+ N9[label="expr 20us"];
+ N10[label="expr v[20us]"];
+ N11[label="stmt v[20us];"];
+ N12[label="block { let v = [2us, 0us, 20us]; v[20us]; }"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 15i"];
+ N2[label="expr 15is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 15i;"];
- N5[label="expr 151i"];
+ N4[label="stmt let mut x = 15is;"];
+ N5[label="expr 151is"];
N6[label="local mut y"];
- N7[label="stmt let mut y = 151i;"];
+ N7[label="stmt let mut y = 151is;"];
N8[label="(dummy_node)"];
- N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l }\l"];
+ N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l }\l"];
N10[label="(dummy_node)"];
- N11[label="expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l"];
+ N11[label="expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l"];
N12[label="expr x"];
- N13[label="expr 1i"];
- N14[label="expr x == 1i"];
+ N13[label="expr 1is"];
+ N14[label="expr x == 1is"];
N15[label="expr break \'outer"];
N16[label="(dummy_node)"];
N17[label="stmt break \'outer ;"];
N18[label="expr \"unreachable\""];
N19[label="stmt \"unreachable\";"];
N20[label="block { break \'outer ; \"unreachable\"; }"];
- N21[label="expr if x == 1i { break \'outer ; \"unreachable\"; }"];
- N22[label="stmt if x == 1i { break \'outer ; \"unreachable\"; }"];
+ N21[label="expr if x == 1is { break \'outer ; \"unreachable\"; }"];
+ N22[label="stmt if x == 1is { break \'outer ; \"unreachable\"; }"];
N23[label="expr y"];
- N24[label="expr 2i"];
- N25[label="expr y >= 2i"];
+ N24[label="expr 2is"];
+ N25[label="expr y >= 2is"];
N26[label="expr return"];
N27[label="(dummy_node)"];
N28[label="stmt return;"];
N29[label="expr \"unreachable\""];
N30[label="stmt \"unreachable\";"];
N31[label="block { return; \"unreachable\"; }"];
- N32[label="expr if y >= 2i { return; \"unreachable\"; }"];
- N33[label="stmt if y >= 2i { return; \"unreachable\"; }"];
- N34[label="expr 3i"];
+ N32[label="expr if y >= 2is { return; \"unreachable\"; }"];
+ N33[label="stmt if y >= 2is { return; \"unreachable\"; }"];
+ N34[label="expr 3is"];
N35[label="expr y"];
- N36[label="expr y -= 3i"];
- N37[label="stmt y -= 3i;"];
- N38[label="expr 5i"];
+ N36[label="expr y -= 3is"];
+ N37[label="stmt y -= 3is;"];
+ N38[label="expr 5is"];
N39[label="expr x"];
- N40[label="expr x -= 5i"];
- N41[label="stmt x -= 5i;"];
- N42[label="block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l}\l"];
- N43[label="stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l"];
+ N40[label="expr x -= 5is"];
+ N41[label="stmt x -= 5is;"];
+ N42[label="block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l}\l"];
+ N43[label="stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l"];
N44[label="expr \"unreachable\""];
N45[label="stmt \"unreachable\";"];
- N46[label="block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l}\l"];
- N47[label="block {\l let mut x = 15i;\l let mut y = 151i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l }\l}\l"];
+ N46[label="block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l}\l"];
+ N47[label="block {\l let mut x = 15is;\l let mut y = 151is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l }\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N12 -> N13;
N13 -> N14;
N14 -> N15;
- N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l}\l"];
+ N15 -> N9[label="exiting scope_0 expr break \'outer,\lexiting scope_1 stmt break \'outer ;,\lexiting scope_2 block { break \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { break \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l}\l"];
N16 -> N17;
N17 -> N18;
N18 -> N19;
N23 -> N24;
N24 -> N25;
N25 -> N26;
- N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { break \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l y -= 3i;\l x -= 5i;\l }\l \"unreachable\";\l }\l"];
+ N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { break \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l y -= 3is;\l x -= 5is;\l }\l \"unreachable\";\l }\l"];
N27 -> N28;
N28 -> N29;
N29 -> N30;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 15i"];
+ N2[label="expr 15is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 15i;"];
- N5[label="expr 151i"];
+ N4[label="stmt let mut x = 15is;"];
+ N5[label="expr 151is"];
N6[label="local mut y"];
- N7[label="stmt let mut y = 151i;"];
+ N7[label="stmt let mut y = 151is;"];
N8[label="(dummy_node)"];
- N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l"];
+ N9[label="expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l"];
N10[label="(dummy_node)"];
- N11[label="expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l"];
+ N11[label="expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l"];
N12[label="expr x"];
- N13[label="expr 1i"];
- N14[label="expr x == 1i"];
+ N13[label="expr 1is"];
+ N14[label="expr x == 1is"];
N15[label="expr continue \'outer"];
N16[label="(dummy_node)"];
N17[label="stmt continue \'outer ;"];
N18[label="expr \"unreachable\""];
N19[label="stmt \"unreachable\";"];
N20[label="block { continue \'outer ; \"unreachable\"; }"];
- N21[label="expr if x == 1i { continue \'outer ; \"unreachable\"; }"];
- N22[label="stmt if x == 1i { continue \'outer ; \"unreachable\"; }"];
+ N21[label="expr if x == 1is { continue \'outer ; \"unreachable\"; }"];
+ N22[label="stmt if x == 1is { continue \'outer ; \"unreachable\"; }"];
N23[label="expr y"];
- N24[label="expr 2i"];
- N25[label="expr y >= 2i"];
+ N24[label="expr 2is"];
+ N25[label="expr y >= 2is"];
N26[label="expr return"];
N27[label="(dummy_node)"];
N28[label="stmt return;"];
N29[label="expr \"unreachable\""];
N30[label="stmt \"unreachable\";"];
N31[label="block { return; \"unreachable\"; }"];
- N32[label="expr if y >= 2i { return; \"unreachable\"; }"];
- N33[label="stmt if y >= 2i { return; \"unreachable\"; }"];
- N34[label="expr 1i"];
+ N32[label="expr if y >= 2is { return; \"unreachable\"; }"];
+ N33[label="stmt if y >= 2is { return; \"unreachable\"; }"];
+ N34[label="expr 1is"];
N35[label="expr x"];
- N36[label="expr x -= 1i"];
- N37[label="stmt x -= 1i;"];
- N38[label="expr 3i"];
+ N36[label="expr x -= 1is"];
+ N37[label="stmt x -= 1is;"];
+ N38[label="expr 3is"];
N39[label="expr y"];
- N40[label="expr y -= 3i"];
- N41[label="stmt y -= 3i;"];
- N42[label="block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l}\l"];
- N43[label="stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l"];
+ N40[label="expr y -= 3is"];
+ N41[label="stmt y -= 3is;"];
+ N42[label="block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l}\l"];
+ N43[label="stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l"];
N44[label="expr \"unreachable\""];
N45[label="stmt \"unreachable\";"];
- N46[label="block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l}\l"];
- N47[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l"];
+ N46[label="block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l}\l"];
+ N47[label="stmt \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l"];
N48[label="expr \"unreachable\""];
N49[label="stmt \"unreachable\";"];
- N50[label="block {\l let mut x = 15i;\l let mut y = 151i;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l \"unreachable\";\l}\l"];
+ N50[label="block {\l let mut x = 15is;\l let mut y = 151is;\l \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l \"unreachable\";\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N12 -> N13;
N13 -> N14;
N14 -> N15;
- N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1i { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l}\l"];
+ N15 -> N8[label="exiting scope_0 expr continue \'outer,\lexiting scope_1 stmt continue \'outer ;,\lexiting scope_2 block { continue \'outer ; \"unreachable\"; },\lexiting scope_3 expr if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_4 stmt if x == 1is { continue \'outer ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l}\l,\lexiting scope_6 expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l,\lexiting scope_7 stmt \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l,\lexiting scope_8 block {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l}\l"];
N16 -> N17;
N17 -> N18;
N18 -> N19;
N23 -> N24;
N24 -> N25;
N25 -> N26;
- N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1i { continue \'outer ; \"unreachable\"; }\l if y >= 2i { return; \"unreachable\"; }\l x -= 1i;\l y -= 3i;\l }\l \"unreachable\";\l }\l"];
+ N26 -> N1[label="exiting scope_0 expr \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l,\lexiting scope_1 expr \'outer:\l loop {\l \'inner:\l loop {\l if x == 1is { continue \'outer ; \"unreachable\"; }\l if y >= 2is { return; \"unreachable\"; }\l x -= 1is;\l y -= 3is;\l }\l \"unreachable\";\l }\l"];
N27 -> N28;
N28 -> N29;
N29 -> N30;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 23i"];
+ N2[label="expr 23is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 23i;"];
- N5[label="expr 23i"];
+ N4[label="stmt let mut x = 23is;"];
+ N5[label="expr 23is"];
N6[label="local mut y"];
- N7[label="stmt let mut y = 23i;"];
- N8[label="expr 23i"];
+ N7[label="stmt let mut y = 23is;"];
+ N8[label="expr 23is"];
N9[label="local mut z"];
- N10[label="stmt let mut z = 23i;"];
+ N10[label="stmt let mut z = 23is;"];
N11[label="(dummy_node)"];
N12[label="expr x"];
- N13[label="expr 0i"];
- N14[label="expr x > 0i"];
- N15[label="expr while x > 0i {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"];
- N16[label="expr 1i"];
+ N13[label="expr 0is"];
+ N14[label="expr x > 0is"];
+ N15[label="expr while x > 0is {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"];
+ N16[label="expr 1is"];
N17[label="expr x"];
- N18[label="expr x -= 1i"];
- N19[label="stmt x -= 1i;"];
+ N18[label="expr x -= 1is"];
+ N19[label="stmt x -= 1is;"];
N20[label="(dummy_node)"];
N21[label="expr y"];
- N22[label="expr 0i"];
- N23[label="expr y > 0i"];
- N24[label="expr while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"];
- N25[label="expr 1i"];
+ N22[label="expr 0is"];
+ N23[label="expr y > 0is"];
+ N24[label="expr while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"];
+ N25[label="expr 1is"];
N26[label="expr y"];
- N27[label="expr y -= 1i"];
- N28[label="stmt y -= 1i;"];
+ N27[label="expr y -= 1is"];
+ N28[label="stmt y -= 1is;"];
N29[label="(dummy_node)"];
N30[label="expr z"];
- N31[label="expr 0i"];
- N32[label="expr z > 0i"];
- N33[label="expr while z > 0i { z -= 1i; }"];
- N34[label="expr 1i"];
+ N31[label="expr 0is"];
+ N32[label="expr z > 0is"];
+ N33[label="expr while z > 0is { z -= 1is; }"];
+ N34[label="expr 1is"];
N35[label="expr z"];
- N36[label="expr z -= 1i"];
- N37[label="stmt z -= 1i;"];
- N38[label="block { z -= 1i; }"];
- N39[label="stmt while z > 0i { z -= 1i; }"];
+ N36[label="expr z -= 1is"];
+ N37[label="stmt z -= 1is;"];
+ N38[label="block { z -= 1is; }"];
+ N39[label="stmt while z > 0is { z -= 1is; }"];
N40[label="expr x"];
- N41[label="expr 10i"];
- N42[label="expr x > 10i"];
+ N41[label="expr 10is"];
+ N42[label="expr x > 10is"];
N43[label="expr return"];
N44[label="(dummy_node)"];
N45[label="stmt return;"];
N46[label="expr \"unreachable\""];
N47[label="stmt \"unreachable\";"];
N48[label="block { return; \"unreachable\"; }"];
- N49[label="expr if x > 10i { return; \"unreachable\"; }"];
- N50[label="block { y -= 1i; while z > 0i { z -= 1i; } if x > 10i { return; \"unreachable\"; } }"];
- N51[label="block {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"];
- N52[label="block {\l let mut x = 23i;\l let mut y = 23i;\l let mut z = 23i;\l while x > 0i {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l }\l}\l"];
+ N49[label="expr if x > 10is { return; \"unreachable\"; }"];
+ N50[label="block {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"];
+ N51[label="block {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"];
+ N52[label="block {\l let mut x = 23is;\l let mut y = 23is;\l let mut z = 23is;\l while x > 0is {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l }\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N40 -> N41;
N41 -> N42;
N42 -> N43;
- N43 -> N1[label="exiting scope_0 expr while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr while x > 0i {\l x -= 1i;\l while y > 0i {\l y -= 1i;\l while z > 0i { z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"];
+ N43 -> N1[label="exiting scope_0 expr while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr while x > 0is {\l x -= 1is;\l while y > 0is {\l y -= 1is;\l while z > 0is { z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"];
N44 -> N45;
N45 -> N46;
N46 -> N47;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 24i"];
+ N2[label="expr 24is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 24i;"];
- N5[label="expr 24i"];
+ N4[label="stmt let mut x = 24is;"];
+ N5[label="expr 24is"];
N6[label="local mut y"];
- N7[label="stmt let mut y = 24i;"];
- N8[label="expr 24i"];
+ N7[label="stmt let mut y = 24is;"];
+ N8[label="expr 24is"];
N9[label="local mut z"];
- N10[label="stmt let mut z = 24i;"];
+ N10[label="stmt let mut z = 24is;"];
N11[label="(dummy_node)"];
- N12[label="expr loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"];
+ N12[label="expr loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"];
N13[label="expr x"];
- N14[label="expr 0i"];
- N15[label="expr x == 0i"];
+ N14[label="expr 0is"];
+ N15[label="expr x == 0is"];
N16[label="expr break"];
N17[label="(dummy_node)"];
N18[label="stmt break ;"];
N19[label="expr \"unreachable\""];
N20[label="stmt \"unreachable\";"];
N21[label="block { break ; \"unreachable\"; }"];
- N22[label="expr if x == 0i { break ; \"unreachable\"; }"];
- N23[label="stmt if x == 0i { break ; \"unreachable\"; }"];
- N24[label="expr 1i"];
+ N22[label="expr if x == 0is { break ; \"unreachable\"; }"];
+ N23[label="stmt if x == 0is { break ; \"unreachable\"; }"];
+ N24[label="expr 1is"];
N25[label="expr x"];
- N26[label="expr x -= 1i"];
- N27[label="stmt x -= 1i;"];
+ N26[label="expr x -= 1is"];
+ N27[label="stmt x -= 1is;"];
N28[label="(dummy_node)"];
- N29[label="expr loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"];
+ N29[label="expr loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"];
N30[label="expr y"];
- N31[label="expr 0i"];
- N32[label="expr y == 0i"];
+ N31[label="expr 0is"];
+ N32[label="expr y == 0is"];
N33[label="expr break"];
N34[label="(dummy_node)"];
N35[label="stmt break ;"];
N36[label="expr \"unreachable\""];
N37[label="stmt \"unreachable\";"];
N38[label="block { break ; \"unreachable\"; }"];
- N39[label="expr if y == 0i { break ; \"unreachable\"; }"];
- N40[label="stmt if y == 0i { break ; \"unreachable\"; }"];
- N41[label="expr 1i"];
+ N39[label="expr if y == 0is { break ; \"unreachable\"; }"];
+ N40[label="stmt if y == 0is { break ; \"unreachable\"; }"];
+ N41[label="expr 1is"];
N42[label="expr y"];
- N43[label="expr y -= 1i"];
- N44[label="stmt y -= 1i;"];
+ N43[label="expr y -= 1is"];
+ N44[label="stmt y -= 1is;"];
N45[label="(dummy_node)"];
- N46[label="expr loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
+ N46[label="expr loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
N47[label="expr z"];
- N48[label="expr 0i"];
- N49[label="expr z == 0i"];
+ N48[label="expr 0is"];
+ N49[label="expr z == 0is"];
N50[label="expr break"];
N51[label="(dummy_node)"];
N52[label="stmt break ;"];
N53[label="expr \"unreachable\""];
N54[label="stmt \"unreachable\";"];
N55[label="block { break ; \"unreachable\"; }"];
- N56[label="expr if z == 0i { break ; \"unreachable\"; }"];
- N57[label="stmt if z == 0i { break ; \"unreachable\"; }"];
- N58[label="expr 1i"];
+ N56[label="expr if z == 0is { break ; \"unreachable\"; }"];
+ N57[label="stmt if z == 0is { break ; \"unreachable\"; }"];
+ N58[label="expr 1is"];
N59[label="expr z"];
- N60[label="expr z -= 1i"];
- N61[label="stmt z -= 1i;"];
- N62[label="block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
- N63[label="stmt loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
+ N60[label="expr z -= 1is"];
+ N61[label="stmt z -= 1is;"];
+ N62[label="block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
+ N63[label="stmt loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
N64[label="expr x"];
- N65[label="expr 10i"];
- N66[label="expr x > 10i"];
+ N65[label="expr 10is"];
+ N66[label="expr x > 10is"];
N67[label="expr return"];
N68[label="(dummy_node)"];
N69[label="stmt return;"];
N70[label="expr \"unreachable\""];
N71[label="stmt \"unreachable\";"];
N72[label="block { return; \"unreachable\"; }"];
- N73[label="expr if x > 10i { return; \"unreachable\"; }"];
- N74[label="block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"];
- N75[label="block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"];
- N76[label="block {\l let mut x = 24i;\l let mut y = 24i;\l let mut z = 24i;\l loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l }\l}\l"];
+ N73[label="expr if x > 10is { return; \"unreachable\"; }"];
+ N74[label="block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"];
+ N75[label="block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"];
+ N76[label="block {\l let mut x = 24is;\l let mut y = 24is;\l let mut z = 24is;\l loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l }\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N13 -> N14;
N14 -> N15;
N15 -> N16;
- N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"];
+ N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"];
N17 -> N18;
N18 -> N19;
N19 -> N20;
N30 -> N31;
N31 -> N32;
N32 -> N33;
- N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l"];
+ N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l"];
N34 -> N35;
N35 -> N36;
N36 -> N37;
N47 -> N48;
N48 -> N49;
N49 -> N50;
- N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0i { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
+ N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0is { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
N51 -> N52;
N52 -> N53;
N53 -> N54;
N64 -> N65;
N65 -> N66;
N66 -> N67;
- N67 -> N1[label="exiting scope_0 expr loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { return; \"unreachable\"; }\l }\l}\l"];
+ N67 -> N1[label="exiting scope_0 expr loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l}\l,\lexiting scope_1 expr loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { return; \"unreachable\"; }\l }\l}\l"];
N68 -> N69;
N69 -> N70;
N70 -> N71;
digraph block {
N0[label="entry"];
N1[label="exit"];
- N2[label="expr 25i"];
+ N2[label="expr 25is"];
N3[label="local mut x"];
- N4[label="stmt let mut x = 25i;"];
- N5[label="expr 25i"];
+ N4[label="stmt let mut x = 25is;"];
+ N5[label="expr 25is"];
N6[label="local mut y"];
- N7[label="stmt let mut y = 25i;"];
- N8[label="expr 25i"];
+ N7[label="stmt let mut y = 25is;"];
+ N8[label="expr 25is"];
N9[label="local mut z"];
- N10[label="stmt let mut z = 25i;"];
+ N10[label="stmt let mut z = 25is;"];
N11[label="(dummy_node)"];
- N12[label="expr \'a:\l loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l }\l"];
+ N12[label="expr \'a:\l loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l }\l"];
N13[label="expr x"];
- N14[label="expr 0i"];
- N15[label="expr x == 0i"];
+ N14[label="expr 0is"];
+ N15[label="expr x == 0is"];
N16[label="expr break"];
N17[label="(dummy_node)"];
N18[label="stmt break ;"];
N19[label="expr \"unreachable\""];
N20[label="stmt \"unreachable\";"];
N21[label="block { break ; \"unreachable\"; }"];
- N22[label="expr if x == 0i { break ; \"unreachable\"; }"];
- N23[label="stmt if x == 0i { break ; \"unreachable\"; }"];
- N24[label="expr 1i"];
+ N22[label="expr if x == 0is { break ; \"unreachable\"; }"];
+ N23[label="stmt if x == 0is { break ; \"unreachable\"; }"];
+ N24[label="expr 1is"];
N25[label="expr x"];
- N26[label="expr x -= 1i"];
- N27[label="stmt x -= 1i;"];
+ N26[label="expr x -= 1is"];
+ N27[label="stmt x -= 1is;"];
N28[label="(dummy_node)"];
- N29[label="expr \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l"];
+ N29[label="expr \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l"];
N30[label="expr y"];
- N31[label="expr 0i"];
- N32[label="expr y == 0i"];
+ N31[label="expr 0is"];
+ N32[label="expr y == 0is"];
N33[label="expr break"];
N34[label="(dummy_node)"];
N35[label="stmt break ;"];
N36[label="expr \"unreachable\""];
N37[label="stmt \"unreachable\";"];
N38[label="block { break ; \"unreachable\"; }"];
- N39[label="expr if y == 0i { break ; \"unreachable\"; }"];
- N40[label="stmt if y == 0i { break ; \"unreachable\"; }"];
- N41[label="expr 1i"];
+ N39[label="expr if y == 0is { break ; \"unreachable\"; }"];
+ N40[label="stmt if y == 0is { break ; \"unreachable\"; }"];
+ N41[label="expr 1is"];
N42[label="expr y"];
- N43[label="expr y -= 1i"];
- N44[label="stmt y -= 1i;"];
+ N43[label="expr y -= 1is"];
+ N44[label="stmt y -= 1is;"];
N45[label="(dummy_node)"];
- N46[label="expr \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
+ N46[label="expr \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
N47[label="expr z"];
- N48[label="expr 0i"];
- N49[label="expr z == 0i"];
+ N48[label="expr 0is"];
+ N49[label="expr z == 0is"];
N50[label="expr break"];
N51[label="(dummy_node)"];
N52[label="stmt break ;"];
N53[label="expr \"unreachable\""];
N54[label="stmt \"unreachable\";"];
N55[label="block { break ; \"unreachable\"; }"];
- N56[label="expr if z == 0i { break ; \"unreachable\"; }"];
- N57[label="stmt if z == 0i { break ; \"unreachable\"; }"];
- N58[label="expr 1i"];
+ N56[label="expr if z == 0is { break ; \"unreachable\"; }"];
+ N57[label="stmt if z == 0is { break ; \"unreachable\"; }"];
+ N58[label="expr 1is"];
N59[label="expr z"];
- N60[label="expr z -= 1i"];
- N61[label="stmt z -= 1i;"];
- N62[label="block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
- N63[label="stmt \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
+ N60[label="expr z -= 1is"];
+ N61[label="stmt z -= 1is;"];
+ N62[label="block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
+ N63[label="stmt \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
N64[label="expr x"];
- N65[label="expr 10i"];
- N66[label="expr x > 10i"];
+ N65[label="expr 10is"];
+ N66[label="expr x > 10is"];
N67[label="expr continue \'a"];
N68[label="(dummy_node)"];
N69[label="stmt continue \'a ;"];
N70[label="expr \"unreachable\""];
N71[label="stmt \"unreachable\";"];
N72[label="block { continue \'a ; \"unreachable\"; }"];
- N73[label="expr if x > 10i { continue \'a ; \"unreachable\"; }"];
- N74[label="block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l}\l"];
- N75[label="block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l}\l"];
- N76[label="block {\l let mut x = 25i;\l let mut y = 25i;\l let mut z = 25i;\l \'a:\l loop {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a:\l loop {\l if z == 0i { break ; \"unreachable\"; }\l z -= 1i;\l }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l }\l}\l"];
+ N73[label="expr if x > 10is { continue \'a ; \"unreachable\"; }"];
+ N74[label="block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l}\l"];
+ N75[label="block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l}\l"];
+ N76[label="block {\l let mut x = 25is;\l let mut y = 25is;\l let mut z = 25is;\l \'a:\l loop {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a:\l loop {\l if z == 0is { break ; \"unreachable\"; }\l z -= 1is;\l }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l }\l}\l"];
N0 -> N2;
N2 -> N3;
N3 -> N4;
N13 -> N14;
N14 -> N15;
N15 -> N16;
- N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0i { break ; \"unreachable\"; }\l x -= 1i;\l \'a:\l loop {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l }\l}\l"];
+ N16 -> N12[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if x == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if x == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if x == 0is { break ; \"unreachable\"; }\l x -= 1is;\l \'a:\l loop {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l }\l}\l"];
N17 -> N18;
N18 -> N19;
N19 -> N20;
N30 -> N31;
N31 -> N32;
N32 -> N33;
- N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0i { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l}\l"];
+ N33 -> N29[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if y == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if y == 0is { break ; \"unreachable\"; },\lexiting scope_5 block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l}\l"];
N34 -> N35;
N35 -> N36;
N36 -> N37;
N47 -> N48;
N48 -> N49;
N49 -> N50;
- N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0i { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0i { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0i { break ; \"unreachable\"; } z -= 1i; }"];
+ N50 -> N46[label="exiting scope_0 expr break,\lexiting scope_1 stmt break ;,\lexiting scope_2 block { break ; \"unreachable\"; },\lexiting scope_3 expr if z == 0is { break ; \"unreachable\"; },\lexiting scope_4 stmt if z == 0is { break ; \"unreachable\"; },\lexiting scope_5 block { if z == 0is { break ; \"unreachable\"; } z -= 1is; }"];
N51 -> N52;
N52 -> N53;
N53 -> N54;
N64 -> N65;
N65 -> N66;
N66 -> N67;
- N67 -> N28[label="exiting scope_0 expr continue \'a,\lexiting scope_1 stmt continue \'a ;,\lexiting scope_2 block { continue \'a ; \"unreachable\"; },\lexiting scope_3 expr if x > 10i { continue \'a ; \"unreachable\"; },\lexiting scope_4 block {\l if y == 0i { break ; \"unreachable\"; }\l y -= 1i;\l \'a: loop { if z == 0i { break ; \"unreachable\"; } z -= 1i; }\l if x > 10i { continue \'a ; \"unreachable\"; }\l}\l"];
+ N67 -> N28[label="exiting scope_0 expr continue \'a,\lexiting scope_1 stmt continue \'a ;,\lexiting scope_2 block { continue \'a ; \"unreachable\"; },\lexiting scope_3 expr if x > 10is { continue \'a ; \"unreachable\"; },\lexiting scope_4 block {\l if y == 0is { break ; \"unreachable\"; }\l y -= 1is;\l \'a: loop { if z == 0is { break ; \"unreachable\"; } z -= 1is; }\l if x > 10is { continue \'a ; \"unreachable\"; }\l}\l"];
N68 -> N69;
N69 -> N70;
N70 -> N71;
}
fn main() {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let _a = A;
lib::callback(|| panic!());
1i
let _toks_1 = vec![quote_tokens!(cx, /** comment */ fn foo() {})];
let name = quote_tokens!(cx, bar);
let _toks_2 = vec![quote_item!(cx, static $name:int = 2;)];
+ let _toks_4 = quote_tokens!(cx, $name:static $name:sizeof);
let _toks_3 = vec![quote_item!(cx,
/// comment
fn foo() { let $name:int = 3; }
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:plugin_args.rs
+// ignore-stage1
+
+#![feature(plugin)]
+
+#[no_link]
+#[plugin]
+extern crate plugin_args;
+
+fn main() {
+ assert_eq!(plugin_args!(), "#[plugin]");
+}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:plugin_args.rs
+// ignore-stage1
+
+#![feature(plugin)]
+
+#[no_link]
+#[plugin()]
+extern crate plugin_args;
+
+fn main() {
+ assert_eq!(plugin_args!(), "#[plugin()]");
+}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:plugin_args.rs
+// ignore-stage1
+
+#![feature(plugin)]
+
+#[no_link]
+#[plugin(hello(there), how(are="you"))]
+extern crate plugin_args;
+
+fn main() {
+ assert_eq!(plugin_args!(), "#[plugin(hello(there), how(are = \"you\"))]");
+}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:plugin_args.rs
+// ignore-stage1
+
+#![feature(plugin)]
+
+#[no_link]
+#[plugin="foobar"]
+extern crate plugin_args;
+
+fn main() {
+ assert_eq!(plugin_args!(), "#[plugin = \"foobar\"]");
+}
#![feature(lang_items, unboxed_closures)]
#![no_implicit_prelude]
-use std::kinds::Sized;
+use std::marker::Sized;
use std::option::Option::{None, Some, self};
trait Iterator {
#![feature(lang_items, unboxed_closures)]
#![no_implicit_prelude]
-use std::kinds::Sized;
+use std::marker::Sized;
use std::option::Option::{None, Some, self};
trait Iterator {
let mut rbml_w = EBwriter::Encoder::new(&mut wr);
a1.encode(&mut rbml_w);
- let d: serialize::rbml::Doc<'a> = EBDoc::new(wr[]);
+ let d: serialize::rbml::Doc<'a> = EBDoc::new(&wr[]);
let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d);
let a2: A = Decodable::decode(&mut decoder);
assert!(*a1 == a2);
add_int(&mut *ints, 44);
iter_ints(&*ints, |i| {
- println!("int = {}", *i);
+ println!("int = {:?}", *i);
true
});
- println!("ints={}", ints);
+ println!("ints={:?}", ints);
}
}
}
-impl fmt::Show for cat {
+impl fmt::String for cat {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.name)
}
}
pub fn main() {
- Thread::spawn(fails).join();
+ Thread::scoped(fails).join();
}
pub fn main() {
// only panics if println! evaluates its argument.
- debug!("{}", { if true { panic!() } });
+ debug!("{:?}", { if true { panic!() } });
}
pub fn main() {
// exits early if println! evaluates its arguments, otherwise it
// will hit the panic.
- println!("{}", { if true { return; } });
+ println!("{:?}", { if true { return; } });
panic!();
}
#![allow(dead_code)]
#![allow(unused_unsafe)]
-use std::kinds::Sync;
+use std::marker::Sync;
struct Foo {
a: uint,
fn dummy_rng() -> DummyRng { DummyRng::new_unseeded() }
macro_rules! tests {
- ($($expr:expr: $ty:ty /($($test:expr),*);)+) => (pub fn main() {$({
+ ($($expr:expr, $ty:ty, ($($test:expr),*);)+) => (pub fn main() {$({
const C: $ty = $expr;
static S: $ty = $expr;
assert!(eq(C($($test),*), $expr($($test),*)));
tests! {
// Free function.
- id: fn(int) -> int /(5);
- id::<int>: fn(int) -> int /(5);
+ id, fn(int) -> int, (5);
+ id::<int>, fn(int) -> int, (5);
// Enum variant constructor.
- Some: fn(int) -> Option<int> /(5);
- Some::<int>: fn(int) -> Option<int> /(5);
+ Some, fn(int) -> Option<int>, (5);
+ Some::<int>, fn(int) -> Option<int>, (5);
// Tuple struct constructor.
- Newt: fn(int) -> Newt<int> /(5);
- Newt::<int>: fn(int) -> Newt<int> /(5);
+ Newt, fn(int) -> Newt<int>, (5);
+ Newt::<int>, fn(int) -> Newt<int>, (5);
// Inherent static methods.
- Vec::new: fn() -> Vec<()> /();
- Vec::<()>::new: fn() -> Vec<()> /();
- Vec::with_capacity: fn(uint) -> Vec<()> /(5);
- Vec::<()>::with_capacity: fn(uint) -> Vec<()> /(5);
- Bitv::from_fn: fn(uint, fn(uint) -> bool) -> Bitv /(5, odd);
- Bitv::from_fn::<fn(uint) -> bool>: fn(uint, fn(uint) -> bool) -> Bitv /(5, odd);
+ Vec::new, fn() -> Vec<()>, ();
+ Vec::<()>::new, fn() -> Vec<()>, ();
+ Vec::with_capacity, fn(uint) -> Vec<()>, (5);
+ Vec::<()>::with_capacity, fn(uint) -> Vec<()>, (5);
+ Bitv::from_fn, fn(uint, fn(uint) -> bool) -> Bitv, (5, odd);
+ Bitv::from_fn::<fn(uint) -> bool>, fn(uint, fn(uint) -> bool) -> Bitv, (5, odd);
// Inherent non-static method.
- Vec::map_in_place: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
- /(vec![b'f', b'o', b'o'], u8_as_i8);
- Vec::map_in_place::<i8, fn(u8) -> i8>: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
- /(vec![b'f', b'o', b'o'], u8_as_i8);
+ Vec::map_in_place, fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>, (vec![b'f', b'o', b'o'], u8_as_i8);
+ Vec::map_in_place::<i8, fn(u8) -> i8>, fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>,
+ (vec![b'f', b'o', b'o'], u8_as_i8);
// FIXME these break with "type parameter might not appear here pointing at `<u8>`.
// Vec::<u8>::map_in_place: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
- // /(vec![b'f', b'o', b'o'], u8_as_i8);
+ // , (vec![b'f', b'o', b'o'], u8_as_i8);
// Vec::<u8>::map_in_place::<i8, fn(u8) -> i8>: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
- // /(vec![b'f', b'o', b'o'], u8_as_i8);
+ // , (vec![b'f', b'o', b'o'], u8_as_i8);
// Trait static methods.
// FIXME qualified path expressions aka UFCS i.e. <T as Trait>::method.
- Default::default: fn() -> int /();
- Rand::rand: fn(&mut DummyRng) -> int /(&mut dummy_rng());
- Rand::rand::<DummyRng>: fn(&mut DummyRng) -> int /(&mut dummy_rng());
+ Default::default, fn() -> int, ();
+ Rand::rand, fn(&mut DummyRng) -> int, (&mut dummy_rng());
+ Rand::rand::<DummyRng>, fn(&mut DummyRng) -> int, (&mut dummy_rng());
// Trait non-static methods.
- Clone::clone: fn(&int) -> int /(&5);
- FromIterator::from_iter: fn(OptionIter<int>) -> Vec<int> /(Some(5).into_iter());
- FromIterator::from_iter::<OptionIter<int>>: fn(OptionIter<int>) -> Vec<int>
- /(Some(5).into_iter());
+ Clone::clone, fn(&int) -> int, (&5);
+ FromIterator::from_iter, fn(OptionIter<int>) -> Vec<int>, (Some(5).into_iter());
+ FromIterator::from_iter::<OptionIter<int>>, fn(OptionIter<int>) -> Vec<int>
+ , (Some(5).into_iter());
}
_ = rx2.recv() => unsafe { libc::exit(1) },
_ = rx1.recv() => {}
}
- }).detach();
+ });
match p.wait().unwrap() {
ExitStatus(..) => panic!("expected a signal"),
ExitSignal(..) => tx.send(()).unwrap(),
let mut w = Vec::new();
let mut e = Encoder::new(&mut w);
obj.encode(&mut e);
- let doc = rbml::Doc::new(@w[]);
+ let doc = rbml::Doc::new(&w[]);
let mut dec = Decoder::new(doc);
let obj2 = Decodable::decode(&mut dec);
assert!(obj == obj2);
}
let f = Foo { foo: 10 };
- format!("{}", f);
+ format!("{:?}", f);
}
}
}
+trait ToShow {
+ fn to_show(&self) -> String;
+}
+
+impl<T: fmt::Show> ToShow for T {
+ fn to_show(&self) -> String {
+ format!("{:?}", self)
+ }
+}
+
pub fn main() {
- assert_eq!(B::B1.to_string(), "B1".to_string());
- assert_eq!(B::B2.to_string(), "B2".to_string());
- assert_eq!(C::C1(3).to_string(), "C1(3)".to_string());
- assert_eq!(C::C2(B::B2).to_string(), "C2(B2)".to_string());
- assert_eq!(D::D1{ a: 2 }.to_string(), "D1 { a: 2 }".to_string());
- assert_eq!(E.to_string(), "E".to_string());
- assert_eq!(F(3).to_string(), "F(3)".to_string());
- assert_eq!(G(3, 4).to_string(), "G(3, 4)".to_string());
- assert_eq!(G(3, 4).to_string(), "G(3, 4)".to_string());
- assert_eq!(I{ a: 2, b: 4 }.to_string(), "I { a: 2, b: 4 }".to_string());
- assert_eq!(J(Custom).to_string(), "J(yay)".to_string());
+ assert_eq!(B::B1.to_show(), "B1".to_string());
+ assert_eq!(B::B2.to_show(), "B2".to_string());
+ assert_eq!(C::C1(3).to_show(), "C1(3i)".to_string());
+ assert_eq!(C::C2(B::B2).to_show(), "C2(B2)".to_string());
+ assert_eq!(D::D1{ a: 2 }.to_show(), "D1 { a: 2i }".to_string());
+ assert_eq!(E.to_show(), "E".to_string());
+ assert_eq!(F(3).to_show(), "F(3i)".to_string());
+ assert_eq!(G(3, 4).to_show(), "G(3i, 4i)".to_string());
+ assert_eq!(I{ a: 2, b: 4 }.to_show(), "I { a: 2i, b: 4i }".to_string());
+ assert_eq!(J(Custom).to_show(), "J(yay)".to_string());
}
macro_rules! t {
($x:expr, $expected:expr) => {
- assert_eq!(format!("{}", $x), $expected.to_string())
+ assert_eq!(format!("{:?}", $x), $expected.to_string())
}
}
pub fn main() {
t!(Unit, "Unit");
- t!(Tuple(1, 2), "Tuple(1, 2)");
- t!(Struct { x: 1, y: 2 }, "Struct { x: 1, y: 2 }");
+ t!(Tuple(1, 2), "Tuple(1i, 2u)");
+ t!(Struct { x: 1, y: 2 }, "Struct { x: 1i, y: 2u }");
t!(Enum::Nullary, "Nullary");
- t!(Enum::Variant(1, 2), "Variant(1, 2)");
- t!(Enum::StructVariant { x: 1, y: 2 }, "StructVariant { x: 1, y: 2 }");
+ t!(Enum::Variant(1, 2), "Variant(1i, 2u)");
+ t!(Enum::StructVariant { x: 1, y: 2 }, "StructVariant { x: 1i, y: 2u }");
}
type Output = Show + 'static;
fn index<'a>(&'a self, idx: &uint) -> &'a (Show + 'static) {
- static x: uint = 42;
- &x
+ static X: uint = 42;
+ &X as &(Show + 'static)
}
}
fn main() {
assert_eq!(&S[0], "hello");
- assert_eq!(format!("{}", &T[0]).as_slice(), "42");
+ &T[0];
+ // let x = &x as &Show;
}
assert_eq!(size_of::<E>(), size_of::<$t>());
assert_eq!(E::V as $t, $v as $t);
assert_eq!(C as $t, $v as $t);
- assert_eq!(format!("{}", E::V), "V".to_string());
- assert_eq!(format!("{}", C), "V".to_string());
+ assert_eq!(format!("{:?}", E::V), "V".to_string());
+ assert_eq!(format!("{:?}", C), "V".to_string());
}
}
$m::check();
pub fn main() {
unsafe {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let i = &100i;
rust_dbg_call(callback, mem::transmute(i));
}).join();
// Issue 4691: Ensure that functional-struct-updates operates
// correctly and moves rather than copy when appropriate.
-use std::kinds::marker::NoCopy as NP;
+use std::marker::NoCopy as NP;
struct ncint { np: NP, v: int }
fn ncint(v: int) -> ncint { ncint { np: NP, v: v } }
pub fn main() {
let a = Foo { x: 1, y: 2 };
let c = Foo { x: 4, .. a};
- println!("{}", c);
+ println!("{:?}", c);
}
-
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
for i in inputs.iter() {
let ctrl = ctrl.clone();
let i = i.clone();
- Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) ).detach();
+ Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) );
}
}
#![allow(dead_code)]
-use std::kinds::marker;
+use std::marker;
#[derive(Copy)]
struct Foo<T> { x: T }
// A test of the macro system. Can we do HTML literals?
+// ignore-test FIXME #20673
/*
f.write_str("adios")
}
}
-impl fmt::Show for C {
+impl fmt::String for C {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad_integral(true, "☃", "123")
}
t!(format!("{}", true), "true");
t!(format!("{}", '☃'), "☃");
t!(format!("{}", 10i), "10");
- t!(format!("{}", 10i), "10");
t!(format!("{}", 10u), "10");
- t!(format!("{:?}", true), "true");
+ t!(format!("{:?}", '☃'), "'\\u{2603}'");
+ t!(format!("{:?}", 10i), "10i");
+ t!(format!("{:?}", 10u), "10u");
+ t!(format!("{:?}", "true"), "\"true\"");
+ t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\"");
t!(format!("{:o}", 10u), "12");
t!(format!("{:x}", 10u), "a");
t!(format!("{:X}", 10u), "A");
t!(format!("{}", 5i + 5i), "10");
t!(format!("{:#4}", C), "☃123");
- let a: &fmt::Show = &1i;
- t!(format!("{}", a), "1");
+ // FIXME(#20676)
+ // let a: &fmt::Show = &1i;
+ // t!(format!("{:?}", a), "1i");
+
// Formatting strings and their arguments
t!(format!("{}", "a"), "a");
fn f(arr: &[&Foo]) {
for &f in arr.iter() {
- println!("{}", f);
+ println!("{:?}", f);
}
}
let mut p = process::Command::new(args[0].as_slice());
p.arg("child").stdout(process::Ignored).stderr(process::Ignored);
- println!("{}", p.spawn().unwrap().wait());
+ println!("{:?}", p.spawn().unwrap().wait());
}
}
fn do_something_with(a : &mut T<int>) {
- println!("{}", a.next())
+ println!("{:?}", a.next())
}
pub fn main() {
use std::thread::Thread;
fn main() {
- Thread::spawn(move|| customtask()).join().ok().unwrap();
+ Thread::scoped(move|| customtask()).join().ok().unwrap();
}
fn customtask() {
fn main() {
fn test() -> Box<std::any::Any + 'static> { box 1i }
- println!("{}", test())
+ println!("{:?}", test())
}
}
pub fn main() {
- assert_eq!("MyStruct".to_string(), do_stuff(|: s: MyStruct| format!("{}", s)));
+ assert_eq!("MyStruct".to_string(), do_stuff(|: s: MyStruct| format!("{:?}", s)));
}
fn main() {
let (tx, rx) = channel();
- let _t = Thread::spawn(move|| { helper(rx) }).detach();
+ let _t = Thread::spawn(move|| { helper(rx) });
let (snd, rcv) = channel::<int>();
for _ in range(1i, 100000i) {
snd.send(1i).unwrap();
fn main() {
let mut array = [1, 2, 3];
- let pie_slice = array[1..2];
+ let pie_slice = &array[1..2];
}
// Check that both closures are capturing by value
assert_eq!(1, mem::size_of_val(&closure));
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let ok = closure;
}).join().ok().unwrap();
}
let mut stdin = std::io::stdin();
Thread::spawn(move|| {
let _ = stdin.read_to_end();
- }).detach();
+ });
}
pub fn main() {
let mut m = HashMap::new();
m.insert(b"foo".to_vec(), b"bar".to_vec());
- println!("{}", m);
+ println!("{:?}", m);
}
let ss: &&[int] = &s;
let sss: &&&[int] = &ss;
- println!("{}", s[..3]);
- println!("{}", ss[3..]);
- println!("{}", sss[2..4]);
+ println!("{}", &s[0..3]);
+ println!("{}", &ss[3..]);
+ println!("{}", &sss[2..4]);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::kinds::marker;
+use std::marker;
use std::cell::UnsafeCell;
struct MyUnsafePack<T>(UnsafeCell<T>);
struct LifetimeStruct<'a>;
fn main() {
- takes_hrtb_closure(|&mut: lts| println!("{}", lts));
+ takes_hrtb_closure(|&mut: lts| println!("{:?}", lts));
}
fn takes_hrtb_closure<F: for<'a>FnMut(LifetimeStruct<'a>)>(mut f: F) {
fn main() {
let a = Foo { foo: 12i };
let b = Bar { bar: 12i };
- println!("{} {}", a, b);
+ println!("{:?} {:?}", a, b);
}
--- /dev/null
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// A reduced version of the rustbook ice. The problem this encountered
+// had to do with trans ignoring binders.
+
+#![feature(slicing_syntax)]
+#![feature(associated_types)]
+#![feature(macro_rules)]
+
+use std::iter;
+use std::os;
+use std::io::File;
+
+#[allow(unused)]
+pub fn parse_summary<R: Reader>(_: R, _: &Path) {
+ let path_from_root = Path::new("");
+ Path::new(iter::repeat("../")
+ .take(path_from_root.components().count() - 1)
+ .collect::<String>());
+ }
+
+fn main() {
+ let cwd = os::getcwd().unwrap();
+ let src = cwd.clone();
+ let summary = File::open(&src.join("SUMMARY.md"));
+ let _ = parse_summary(summary, &src);
+}
static generations: uint = 1024+256+128+49;
fn spawn(f: Thunk) {
- Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(())).detach()
+ Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(()));
}
fn child_no(x: uint) -> Thunk {
use std::mem::{replace, swap};
use std::mem;
use std::thread::Thread;
- use std::kinds::Send;
+ use std::marker::Send;
pub struct Stuff<T> {
state: state,
// except according to those terms.
pub fn main() {
- println!("{}", ("hi there!", "you"));
+ println!("{:?}", ("hi there!", "you"));
}
"foo".to_string(),
"foo".to_string(), "foo".to_string(), "foo".to_string(),
"foo".to_string());
- let v = format!("{}", u); // this is the line that causes the seg fault
+ let v = format!("{:?}", u); // this is the line that causes the seg fault
assert!(v.len() > 0);
}
let mut table = HashMap::new();
table.insert("one".to_string(), 1i);
table.insert("two".to_string(), 2i);
- assert!(check_strs(table.to_string().as_slice(), "{one: 1, two: 2}") ||
- check_strs(table.to_string().as_slice(), "{two: 2, one: 1}"));
+ assert!(check_strs(format!("{:?}", table).as_slice(), "HashMap {\"one\": 1i, \"two\": 2i}") ||
+ check_strs(format!("{:?}", table).as_slice(), "HashMap {\"two\": 2i, \"one\": 1i}"));
}
// Allows AsciiArt to be converted to a string using the libcore ToString trait.
// Note that the %s fmt! specifier will not call this automatically.
-impl fmt::Show for AsciiArt {
+impl fmt::String for AsciiArt {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// Convert each line into a string.
let lines = self.lines.iter()
}
// Right-hand-side operator visitor pattern
-trait RhsOfVec2Mul<Result> { fn mul_vec2_by(&self, lhs: &Vec2) -> Result; }
+trait RhsOfVec2Mul {
+ type Result;
+
+ fn mul_vec2_by(&self, lhs: &Vec2) -> Self::Result;
+}
// Vec2's implementation of Mul "from the other side" using the above trait
-impl<Res, Rhs: RhsOfVec2Mul<Res>> Mul<Rhs> for Vec2 {
+impl<Res, Rhs: RhsOfVec2Mul<Result=Res>> Mul<Rhs> for Vec2 {
type Output = Res;
fn mul(self, rhs: Rhs) -> Res { rhs.mul_vec2_by(&self) }
}
// Implementation of 'f64 as right-hand-side of Vec2::Mul'
-impl RhsOfVec2Mul<Vec2> for f64 {
+impl RhsOfVec2Mul for f64 {
+ type Result = Vec2;
+
fn mul_vec2_by(&self, lhs: &Vec2) -> Vec2 { lhs.vmul(*self) }
}
impl T for S {
fn print(&self) {
- println!("{}", self);
+ println!("{:?}", self);
}
}
#![feature(slicing_syntax)]
fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
- v[1..5]
+ &v[1..5]
}
pub fn main() {}
trait X {
fn call<T: std::fmt::Show>(&self, x: &T);
fn default_method<T: std::fmt::Show>(&self, x: &T) {
- println!("X::default_method {}", x);
+ println!("X::default_method {:?}", x);
}
}
impl X for Y {
fn call<T: std::fmt::Show>(&self, x: &T) {
- println!("X::call {} {}", self, x);
+ println!("X::call {:?} {:?}", self, x);
}
}
tx.send("hello, world").unwrap();
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
println(rx.recv().unwrap());
}).join().ok().unwrap();
}
pub fn main() {
let (tx, rx) = channel::<&'static str>();
- let t = Thread::spawn(move|| {
+ let t = Thread::scoped(move|| {
assert_eq!(rx.recv().unwrap(), "hello, world");
});
#![feature(slicing_syntax)]
-fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { v[i..j] }
+fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { &v[i..j] }
pub fn main() {}
let sa = A { a: 100 };
let sb = B { b: 200, pa: &sa };
- println!("sa is {}", sa);
- println!("sb is {}", sb);
+ println!("sa is {:?}", sa);
+ println!("sb is {:?}", sb);
}
use std::thread::Thread;
fn main() {
- assert!(Thread::spawn(move|| int::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i8::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i16::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i32::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| i64::MIN / -1).join().is_err());
- assert!(Thread::spawn(move|| 1i / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i8 / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i16 / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i32 / 0).join().is_err());
- assert!(Thread::spawn(move|| 1i64 / 0).join().is_err());
- assert!(Thread::spawn(move|| int::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i8::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i16::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i32::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| i64::MIN % -1).join().is_err());
- assert!(Thread::spawn(move|| 1i % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i8 % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i16 % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i32 % 0).join().is_err());
- assert!(Thread::spawn(move|| 1i64 % 0).join().is_err());
+ assert!(Thread::scoped(move|| int::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i8::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i16::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i32::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| i64::MIN / -1).join().is_err());
+ assert!(Thread::scoped(move|| 1i / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i8 / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i16 / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i32 / 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i64 / 0).join().is_err());
+ assert!(Thread::scoped(move|| int::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i8::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i16::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i32::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| i64::MIN % -1).join().is_err());
+ assert!(Thread::scoped(move|| 1i % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i8 % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i16 % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i32 % 0).join().is_err());
+ assert!(Thread::scoped(move|| 1i64 % 0).join().is_err());
}
Err(..) => break
}
}
- }).detach();
+ });
return port;
}
}
i = i + 1;
}
- }).detach();
+ });
return port;
}
}
}
}
-
#![feature(slicing_syntax)]
fn assert_repr_eq<T: std::fmt::Show>(obj : T, expected : String) {
- assert_eq!(expected, format!("{}", obj));
+ assert_eq!(expected, format!("{:?}", obj));
}
pub fn main() {
let abc = [1i, 2, 3];
let tf = [true, false];
let x = [(), ()];
- let slice = x[0..1];
+ let slice = &x[0..1];
- assert_repr_eq(abc[], "[1, 2, 3]".to_string());
- assert_repr_eq(tf[], "[true, false]".to_string());
- assert_repr_eq(x[], "[(), ()]".to_string());
+ assert_repr_eq(&abc[], "[1i, 2i, 3i]".to_string());
+ assert_repr_eq(&tf[], "[true, false]".to_string());
+ assert_repr_eq(&x[], "[(), ()]".to_string());
assert_repr_eq(slice, "[()]".to_string());
- assert_repr_eq(x[], "[(), ()]".to_string());
+ assert_repr_eq(&x[], "[(), ()]".to_string());
}
}
fn check_log<T: std::fmt::Show>(exp: String, v: T) {
- assert_eq!(exp, format!("{}", v));
+ assert_eq!(exp, format!("{:?}", v));
}
pub fn main() {
let mut x = Some(foo::a(22u));
- let exp = "Some(a(22))".to_string();
- let act = format!("{}", x);
+ let exp = "Some(a(22u))".to_string();
+ let act = format!("{:?}", x);
assert_eq!(act, exp);
check_log(exp, x);
x = None;
let exp = "None".to_string();
- let act = format!("{}", x);
+ let act = format!("{:?}", x);
assert_eq!(act, exp);
check_log(exp, x);
}
}
pub fn main() {
- assert_eq!("a(22)".to_string(), format!("{}", foo::a(22u)));
- assert_eq!("c".to_string(), format!("{}", foo::c));
- assert_eq!("d".to_string(), format!("{}", bar::d));
+ assert_eq!("a(22u)".to_string(), format!("{:?}", foo::a(22u)));
+ assert_eq!("c".to_string(), format!("{:?}", foo::c));
+ assert_eq!("d".to_string(), format!("{:?}", bar::d));
}
}
pub fn main() {
- println!("{}", 1i);
- println!("{}", 2.0f64);
- println!("{}", Numbers::Three);
- println!("{}", vec!(4i));
+ println!("{:?}", 1i);
+ println!("{:?}", 2.0f64);
+ println!("{:?}", Numbers::Three);
+ println!("{:?}", vec!(4i));
}
}
pub fn main() {
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
let mut f = Foo(Cell::new(0));
- println!("{}", f);
+ println!("{:?}", f);
let Foo(ref mut f) = f;
assert!(f.get() == 1);
}).join().ok().unwrap();
macro_rules! spawn {
($($code: tt)*) => {
- expr!(Thread::spawn(move|| {$($code)*}).detach())
+ expr!(Thread::spawn(move|| {$($code)*}))
}
}
// know not to stop at the blanket, we have to recursively evaluate
// the `T:Foo` bound.
-use std::kinds::Sized;
+use std::marker::Sized;
// Note: this must be generic for the problem to show up
trait Foo<A> {
impl fmt::Show for Thingy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{{ x: {}, y: {} }}", self.x, self.y)
+ write!(f, "{{ x: {:?}, y: {:?} }}", self.x, self.y)
}
}
impl<T:fmt::Show> fmt::Show for PolymorphicThingy<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", self.x)
+ write!(f, "{:?}", self.x)
}
}
pub fn main() {
- println!("{}", Thingy { x: 1, y: 2 }.to_string());
- println!("{}", PolymorphicThingy { x: Thingy { x: 1, y: 2 } }.to_string());
+ println!("{:?}", Thingy { x: 1, y: 2 });
+ println!("{:?}", PolymorphicThingy { x: Thingy { x: 1, y: 2 } });
}
}
fn main() {
- Thread::spawn(move|| -> () {
+ Thread::scoped(move|| -> () {
let _a = A;
panic!();
}).join().unwrap_err();
}
macro_rules! check_option {
- ($e:expr: $T:ty) => {{
- check_option!($e: $T, |ptr| assert!(*ptr == $e));
+ ($e:expr, $T:ty) => {{
+ check_option!($e, $T, |ptr| assert!(*ptr == $e));
}};
- ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{
+ ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
assert!(option::Option::None::<$T>.is_none());
let e = $e;
let s_ = option::Option::Some::<$T>(e);
}
macro_rules! check_fancy {
- ($e:expr: $T:ty) => {{
- check_fancy!($e: $T, |ptr| assert!(*ptr == $e));
+ ($e:expr, $T:ty) => {{
+ check_fancy!($e, $T, |ptr| assert!(*ptr == $e));
}};
- ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{
+ ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
assert!(E::Nothing::<$T>((), ((), ()), [23i8; 0]).is_none());
let e = $e;
let t_ = E::Thing::<$T>(23, e);
}
pub fn main() {
- check_type!(&17: &int);
- check_type!(box 18: Box<int>);
- check_type!("foo".to_string(): String);
- check_type!(vec!(20, 22): Vec<int> );
+ check_type!(&17, &int);
+ check_type!(box 18, Box<int>);
+ check_type!("foo".to_string(), String);
+ check_type!(vec!(20, 22), Vec<int> );
let mint: uint = unsafe { mem::transmute(main) };
- check_type!(main: fn(), |pthing| {
+ check_type!(main, fn(), |pthing| {
assert!(mint == unsafe { mem::transmute(*pthing) })
});
}
let args = os::args();
let args = args.as_slice();
if args.len() > 1 && args[1].as_slice() == "recurse" {
- let _t = Thread::spawn(recurse);
+ let _t = Thread::scoped(recurse);
} else {
let recurse = Command::new(args[0].as_slice()).arg("recurse").output().unwrap();
assert!(!recurse.status.success());
let error = String::from_utf8_lossy(recurse.error.as_slice());
+ println!("wut");
+ println!("`{}`", error);
assert!(error.as_slice().contains("has overflowed its stack"));
}
}
return &pair.value
}
}
- panic!("No value found for key: {}", index);
+ panic!("No value found for key: {:?}", index);
}
}
}
pub fn main() {
- let ret = Thread::spawn(move|| {
+ let ret = Thread::scoped(move|| {
let _a = A { b: B { foo: 3 } };
}).join();
assert!(ret.is_err());
unsafe { assert!(dropped); }
}
-
+++ /dev/null
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin]
-extern crate plugin_args;
-
-fn main() {
- assert_eq!(plugin_args!(), "#[plugin]");
-}
+++ /dev/null
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin()]
-extern crate plugin_args;
-
-fn main() {
- assert_eq!(plugin_args!(), "#[plugin()]");
-}
+++ /dev/null
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin(hello(there), how(are="you"))]
-extern crate plugin_args;
-
-fn main() {
- assert_eq!(plugin_args!(), "#[plugin(hello(there), how(are = \"you\"))]");
-}
+++ /dev/null
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin="foobar"]
-extern crate plugin_args;
-
-fn main() {
- assert_eq!(plugin_args!(), "#[plugin = \"foobar\"]");
-}
let x = Outer {c8: 22u8, t: Inner {c64: 44u32}};
// Send it through the shape code
- let y = format!("{}", x);
+ let y = format!("{:?}", x);
- println!("align inner = {}", rusti::min_align_of::<Inner>());
- println!("size outer = {}", mem::size_of::<Outer>());
- println!("y = {}", y);
+ println!("align inner = {:?}", rusti::min_align_of::<Inner>());
+ println!("size outer = {:?}", mem::size_of::<Outer>());
+ println!("y = {:?}", y);
// per clang/gcc the alignment of `inner` is 4 on x86.
assert_eq!(rusti::min_align_of::<Inner>(), m::align());
// because `inner`s alignment was 4.
assert_eq!(mem::size_of::<Outer>(), m::size());
- assert_eq!(y, "Outer { c8: 22, t: Inner { c64: 44 } }".to_string());
+ assert_eq!(y, "Outer { c8: 22u8, t: Inner { c64: 44u32 } }".to_string());
}
}
unsafe {
let x = Outer {c8: 22u8, t: Inner {c64: 44u64}};
- let y = format!("{}", x);
+ let y = format!("{:?}", x);
- println!("align inner = {}", rusti::min_align_of::<Inner>());
- println!("size outer = {}", mem::size_of::<Outer>());
- println!("y = {}", y);
+ println!("align inner = {:?}", rusti::min_align_of::<Inner>());
+ println!("size outer = {:?}", mem::size_of::<Outer>());
+ println!("y = {:?}", y);
// per clang/gcc the alignment of `Inner` is 4 on x86.
assert_eq!(rusti::min_align_of::<Inner>(), m::m::align());
// because `Inner`s alignment was 4.
assert_eq!(mem::size_of::<Outer>(), m::m::size());
- assert_eq!(y, "Outer { c8: 22, t: Inner { c64: 44 } }".to_string());
+ assert_eq!(y, "Outer { c8: 22u8, t: Inner { c64: 44u64 } }".to_string());
}
}
// Test that a type whose lifetime parameters is never used is
// inferred to be bivariant.
-use std::kinds::marker;
+use std::marker;
struct Bivariant<'a>;
print!("[");
for xi in x.iter() {
- print!("{}, ", (*xi)[]);
+ print!("{}, ", &xi[]);
}
println!("]");
- println!("{}", y[]);
+ println!("{}", &y[]);
}
let a = r(i);
let b = (a, 10i);
let (c, _d) = b;
- println!("{}", c);
+ println!("{:?}", c);
}
assert_eq!(i.get(), 1);
}
fn pass(output: ProcessOutput) {
if !output.status.success() {
- println!("{}", str::from_utf8(output.output.as_slice()));
- println!("{}", str::from_utf8(output.error.as_slice()));
+ println!("{:?}", str::from_utf8(output.output.as_slice()));
+ println!("{:?}", str::from_utf8(output.error.as_slice()));
}
}
println!("{}", *three + n); // will copy x into the closure
assert_eq!(*three, 3);
};
- Thread::spawn(move|| {
+ Thread::scoped(move|| {
test05_start(fn_to_send);
}).join().ok().unwrap();
}
}
fn main() {
- Thread::spawn(move|| { ::b::g() }).join().unwrap_err();
+ Thread::scoped(move|| { ::b::g() }).join().unwrap_err();
}
struct Foo(Box<[u8]>);
pub fn main() {
- println!("{}", Foo(box [0, 1, 2]));
+ println!("{:?}", Foo(box [0, 1, 2]));
}
fn main() {
let x: &[int] = &[1, 2, 3, 4, 5];
let cmp: &[int] = &[1, 2, 3, 4, 5];
- assert!(x[] == cmp);
+ assert!(&x[] == cmp);
let cmp: &[int] = &[3, 4, 5];
- assert!(x[2..] == cmp);
+ assert!(&x[2..] == cmp);
let cmp: &[int] = &[1, 2, 3];
- assert!(x[..3] == cmp);
+ assert!(&x[0..3] == cmp);
let cmp: &[int] = &[2, 3, 4];
- assert!(x[1..4] == cmp);
+ assert!(&x[1..4] == cmp);
let x: Vec<int> = vec![1, 2, 3, 4, 5];
let cmp: &[int] = &[1, 2, 3, 4, 5];
- assert!(x[] == cmp);
+ assert!(&x[] == cmp);
let cmp: &[int] = &[3, 4, 5];
- assert!(x[2..] == cmp);
+ assert!(&x[2..] == cmp);
let cmp: &[int] = &[1, 2, 3];
- assert!(x[..3] == cmp);
+ assert!(&x[0..3] == cmp);
let cmp: &[int] = &[2, 3, 4];
- assert!(x[1..4] == cmp);
+ assert!(&x[1..4] == cmp);
let x: &mut [int] = &mut [1, 2, 3, 4, 5];
{
let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
- assert!(x[mut] == cmp);
+ assert!(&mut x[] == cmp);
}
{
let cmp: &mut [int] = &mut [3, 4, 5];
- assert!(x[mut 2..] == cmp);
+ assert!(&mut x[2..] == cmp);
}
{
let cmp: &mut [int] = &mut [1, 2, 3];
- assert!(x[mut ..3] == cmp);
+ assert!(&mut x[..3] == cmp);
}
{
let cmp: &mut [int] = &mut [2, 3, 4];
- assert!(x[mut 1..4] == cmp);
+ assert!(&mut x[1..4] == cmp);
}
let mut x: Vec<int> = vec![1, 2, 3, 4, 5];
{
let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
- assert!(x[mut] == cmp);
+ assert!(&mut x[] == cmp);
}
{
let cmp: &mut [int] = &mut [3, 4, 5];
- assert!(x[mut 2..] == cmp);
+ assert!(&mut x[2..] == cmp);
}
{
let cmp: &mut [int] = &mut [1, 2, 3];
- assert!(x[mut ..3] == cmp);
+ assert!(&mut x[..3] == cmp);
}
{
let cmp: &mut [int] = &mut [2, 3, 4];
- assert!(x[mut 1..4] == cmp);
+ assert!(&mut x[1..4] == cmp);
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test that is a slicing expr[..] fails, the correct cleanups happen.
+// Test that if a slicing expr[..] fails, the correct cleanups happen.
#![feature(slicing_syntax)]
fn foo() {
let x: &[_] = &[Foo, Foo];
- x[3..4];
+ &x[3..4];
}
fn main() {
- let _ = Thread::spawn(move|| foo()).join();
+ let _ = Thread::scoped(move|| foo()).join();
unsafe { assert!(DTOR_COUNT == 2); }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test that is a slicing expr[..] fails, the correct cleanups happen.
+// Test that if a slicing expr[..] fails, the correct cleanups happen.
#![feature(slicing_syntax)]
fn foo() {
let x: &[_] = &[Foo, Foo];
- x[3..bar()];
+ &x[3..bar()];
}
fn main() {
- let _ = Thread::spawn(move|| foo()).join();
+ let _ = Thread::scoped(move|| foo()).join();
unsafe { assert!(DTOR_COUNT == 2); }
}
// Test slicing sugar.
#![feature(slicing_syntax)]
+#![feature(associated_types)]
extern crate core;
-use core::ops::{Slice,SliceMut};
+use core::ops::{Index, Range, RangeTo, RangeFrom, FullRange};
static mut COUNT: uint = 0;
struct Foo;
-impl Slice<Foo, Foo> for Foo {
- fn as_slice_<'a>(&'a self) -> &'a Foo {
+impl Index<Range<Foo>> for Foo {
+ type Output = Foo;
+ fn index(&self, index: &Range<Foo>) -> &Foo {
unsafe { COUNT += 1; }
self
}
- fn slice_from_or_fail<'a>(&'a self, _from: &Foo) -> &'a Foo {
+}
+impl Index<RangeTo<Foo>> for Foo {
+ type Output = Foo;
+ fn index(&self, index: &RangeTo<Foo>) -> &Foo {
unsafe { COUNT += 1; }
self
}
- fn slice_to_or_fail<'a>(&'a self, _to: &Foo) -> &'a Foo {
+}
+impl Index<RangeFrom<Foo>> for Foo {
+ type Output = Foo;
+ fn index(&self, index: &RangeFrom<Foo>) -> &Foo {
unsafe { COUNT += 1; }
self
}
- fn slice_or_fail<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo {
+}
+impl Index<FullRange> for Foo {
+ type Output = Foo;
+ fn index(&self, _index: &FullRange) -> &Foo {
unsafe { COUNT += 1; }
self
}
}
-impl SliceMut<Foo, Foo> for Foo {
- fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo {
+impl IndexMut<Range<Foo>> for Foo {
+ type Output = Foo;
+ fn index_mut(&mut self, index: &Range<Foo>) -> &mut Foo {
unsafe { COUNT += 1; }
self
}
- fn slice_from_or_fail_mut<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo {
+}
+impl IndexMut<RangeTo<Foo>> for Foo {
+ type Output = Foo;
+ fn index_mut(&mut self, index: &RangeTo<Foo>) -> &mut Foo {
unsafe { COUNT += 1; }
self
}
- fn slice_to_or_fail_mut<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo {
+}
+impl IndexMut<RangeFrom<Foo>> for Foo {
+ type Output = Foo;
+ fn index_mut(&mut self, index: &RangeFrom<Foo>) -> &mut Foo {
unsafe { COUNT += 1; }
self
}
- fn slice_or_fail_mut<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo {
+}
+impl IndexMut<FullRange> for Foo {
+ type Output = Foo;
+ fn index_mut(&mut self, _index: &FullRange) -> &mut Foo {
unsafe { COUNT += 1; }
self
}
}
+
+
fn main() {
let mut x = Foo;
- x[];
- x[Foo..];
- x[..Foo];
- x[Foo..Foo];
- x[mut];
- x[mut Foo..];
- x[mut ..Foo];
- x[mut Foo..Foo];
+ &x[];
+ &x[Foo..];
+ &x[..Foo];
+ &x[Foo..Foo];
+ &mut x[];
+ &mut x[Foo..];
+ &mut x[..Foo];
+ &mut x[Foo..Foo];
unsafe {
assert!(COUNT == 8);
}
static S: $t = $e;
let v: $t = $e;
assert_eq!(S, v);
- assert_eq!(format!("{}", v).as_slice(), $s);
- assert_eq!(format!("{}", S).as_slice(), $s);
+ assert_eq!(format!("{:?}", v).as_slice(), $s);
+ assert_eq!(format!("{:?}", S).as_slice(), $s);
});*
}}
}
pub fn main() {
check!(Option<u8>, 2,
None, "None",
- Some(129u8), "Some(129)");
+ Some(129u8), "Some(129u8)");
check!(Option<i16>, 4,
None, "None",
- Some(-20000i16), "Some(-20000)");
+ Some(-20000i16), "Some(-20000i16)");
check!(Either<u8, i8>, 2,
- Either::Left(132u8), "Left(132)",
- Either::Right(-32i8), "Right(-32)");
+ Either::Left(132u8), "Left(132u8)",
+ Either::Right(-32i8), "Right(-32i8)");
check!(Either<u8, i16>, 4,
- Either::Left(132u8), "Left(132)",
- Either::Right(-20000i16), "Right(-20000)");
+ Either::Left(132u8), "Left(132u8)",
+ Either::Right(-20000i16), "Right(-20000i16)");
}
pub fn main() {
let (tx, _rx) = channel::<int>();
- let t = Thread::spawn(move|| iotask(&tx, "localhost".to_string()) );
+ let t = Thread::scoped(move|| iotask(&tx, "localhost".to_string()) );
t.join().ok().unwrap();
}
use std::thread::Thread;
pub fn main() {
- Thread::spawn(move|| child(10)).join().ok().unwrap();
+ Thread::scoped(move|| child(10)).join().ok().unwrap();
}
fn child(i: int) { println!("{}", i); assert!((i == 10)); }
use std::thread::Thread;
pub fn main() {
- let t = Thread::spawn(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
+ let t = Thread::scoped(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
t.join().ok().unwrap();
}
pub fn main() {
let mut t = Builder::new();
- t.spawn(move|| ()).detach();
+ t.spawn(move|| ());
}
pub fn main() {
let f = 1u as *const libc::FILE;
- println!("{}", f as int);
- println!("{}", f as uint);
- println!("{}", f as i8);
- println!("{}", f as i16);
- println!("{}", f as i32);
- println!("{}", f as i64);
- println!("{}", f as u8);
- println!("{}", f as u16);
- println!("{}", f as u32);
- println!("{}", f as u64);
-
- println!("{}", 1 as int);
- println!("{}", 1 as uint);
- println!("{}", 1 as *const libc::FILE);
- println!("{}", 1 as i8);
- println!("{}", 1 as i16);
- println!("{}", 1 as i32);
- println!("{}", 1 as i64);
- println!("{}", 1 as u8);
- println!("{}", 1 as u16);
- println!("{}", 1 as u32);
- println!("{}", 1 as u64);
- println!("{}", 1i as f32);
- println!("{}", 1i as f64);
-
- println!("{}", 1u as int);
- println!("{}", 1u as uint);
- println!("{}", 1u as *const libc::FILE);
- println!("{}", 1u as i8);
- println!("{}", 1u as i16);
- println!("{}", 1u as i32);
- println!("{}", 1u as i64);
- println!("{}", 1u as u8);
- println!("{}", 1u as u16);
- println!("{}", 1u as u32);
- println!("{}", 1u as u64);
- println!("{}", 1u as f32);
- println!("{}", 1u as f64);
-
- println!("{}", 1i8 as int);
- println!("{}", 1i8 as uint);
- println!("{}", 1i8 as *const libc::FILE);
- println!("{}", 1i8 as i8);
- println!("{}", 1i8 as i16);
- println!("{}", 1i8 as i32);
- println!("{}", 1i8 as i64);
- println!("{}", 1i8 as u8);
- println!("{}", 1i8 as u16);
- println!("{}", 1i8 as u32);
- println!("{}", 1i8 as u64);
- println!("{}", 1i8 as f32);
- println!("{}", 1i8 as f64);
-
- println!("{}", 1u8 as int);
- println!("{}", 1u8 as uint);
- println!("{}", 1u8 as *const libc::FILE);
- println!("{}", 1u8 as i8);
- println!("{}", 1u8 as i16);
- println!("{}", 1u8 as i32);
- println!("{}", 1u8 as i64);
- println!("{}", 1u8 as u8);
- println!("{}", 1u8 as u16);
- println!("{}", 1u8 as u32);
- println!("{}", 1u8 as u64);
- println!("{}", 1u8 as f32);
- println!("{}", 1u8 as f64);
-
- println!("{}", 1i16 as int);
- println!("{}", 1i16 as uint);
- println!("{}", 1i16 as *const libc::FILE);
- println!("{}", 1i16 as i8);
- println!("{}", 1i16 as i16);
- println!("{}", 1i16 as i32);
- println!("{}", 1i16 as i64);
- println!("{}", 1i16 as u8);
- println!("{}", 1i16 as u16);
- println!("{}", 1i16 as u32);
- println!("{}", 1i16 as u64);
- println!("{}", 1i16 as f32);
- println!("{}", 1i16 as f64);
-
- println!("{}", 1u16 as int);
- println!("{}", 1u16 as uint);
- println!("{}", 1u16 as *const libc::FILE);
- println!("{}", 1u16 as i8);
- println!("{}", 1u16 as i16);
- println!("{}", 1u16 as i32);
- println!("{}", 1u16 as i64);
- println!("{}", 1u16 as u8);
- println!("{}", 1u16 as u16);
- println!("{}", 1u16 as u32);
- println!("{}", 1u16 as u64);
- println!("{}", 1u16 as f32);
- println!("{}", 1u16 as f64);
-
- println!("{}", 1i32 as int);
- println!("{}", 1i32 as uint);
- println!("{}", 1i32 as *const libc::FILE);
- println!("{}", 1i32 as i8);
- println!("{}", 1i32 as i16);
- println!("{}", 1i32 as i32);
- println!("{}", 1i32 as i64);
- println!("{}", 1i32 as u8);
- println!("{}", 1i32 as u16);
- println!("{}", 1i32 as u32);
- println!("{}", 1i32 as u64);
- println!("{}", 1i32 as f32);
- println!("{}", 1i32 as f64);
-
- println!("{}", 1u32 as int);
- println!("{}", 1u32 as uint);
- println!("{}", 1u32 as *const libc::FILE);
- println!("{}", 1u32 as i8);
- println!("{}", 1u32 as i16);
- println!("{}", 1u32 as i32);
- println!("{}", 1u32 as i64);
- println!("{}", 1u32 as u8);
- println!("{}", 1u32 as u16);
- println!("{}", 1u32 as u32);
- println!("{}", 1u32 as u64);
- println!("{}", 1u32 as f32);
- println!("{}", 1u32 as f64);
-
- println!("{}", 1i64 as int);
- println!("{}", 1i64 as uint);
- println!("{}", 1i64 as *const libc::FILE);
- println!("{}", 1i64 as i8);
- println!("{}", 1i64 as i16);
- println!("{}", 1i64 as i32);
- println!("{}", 1i64 as i64);
- println!("{}", 1i64 as u8);
- println!("{}", 1i64 as u16);
- println!("{}", 1i64 as u32);
- println!("{}", 1i64 as u64);
- println!("{}", 1i64 as f32);
- println!("{}", 1i64 as f64);
-
- println!("{}", 1u64 as int);
- println!("{}", 1u64 as uint);
- println!("{}", 1u64 as *const libc::FILE);
- println!("{}", 1u64 as i8);
- println!("{}", 1u64 as i16);
- println!("{}", 1u64 as i32);
- println!("{}", 1u64 as i64);
- println!("{}", 1u64 as u8);
- println!("{}", 1u64 as u16);
- println!("{}", 1u64 as u32);
- println!("{}", 1u64 as u64);
- println!("{}", 1u64 as f32);
- println!("{}", 1u64 as f64);
-
- println!("{}", 1u64 as int);
- println!("{}", 1u64 as uint);
- println!("{}", 1u64 as *const libc::FILE);
- println!("{}", 1u64 as i8);
- println!("{}", 1u64 as i16);
- println!("{}", 1u64 as i32);
- println!("{}", 1u64 as i64);
- println!("{}", 1u64 as u8);
- println!("{}", 1u64 as u16);
- println!("{}", 1u64 as u32);
- println!("{}", 1u64 as u64);
- println!("{}", 1u64 as f32);
- println!("{}", 1u64 as f64);
-
- println!("{}", true as int);
- println!("{}", true as uint);
- println!("{}", true as *const libc::FILE);
- println!("{}", true as i8);
- println!("{}", true as i16);
- println!("{}", true as i32);
- println!("{}", true as i64);
- println!("{}", true as u8);
- println!("{}", true as u16);
- println!("{}", true as u32);
- println!("{}", true as u64);
- println!("{}", true as f32);
- println!("{}", true as f64);
-
- println!("{}", 1f32 as int);
- println!("{}", 1f32 as uint);
- println!("{}", 1f32 as i8);
- println!("{}", 1f32 as i16);
- println!("{}", 1f32 as i32);
- println!("{}", 1f32 as i64);
- println!("{}", 1f32 as u8);
- println!("{}", 1f32 as u16);
- println!("{}", 1f32 as u32);
- println!("{}", 1f32 as u64);
- println!("{}", 1f32 as f32);
- println!("{}", 1f32 as f64);
-
- println!("{}", 1f64 as int);
- println!("{}", 1f64 as uint);
- println!("{}", 1f64 as i8);
- println!("{}", 1f64 as i16);
- println!("{}", 1f64 as i32);
- println!("{}", 1f64 as i64);
- println!("{}", 1f64 as u8);
- println!("{}", 1f64 as u16);
- println!("{}", 1f64 as u32);
- println!("{}", 1f64 as u64);
- println!("{}", 1f64 as f32);
- println!("{}", 1f64 as f64);
+ println!("{:?}", f as int);
+ println!("{:?}", f as uint);
+ println!("{:?}", f as i8);
+ println!("{:?}", f as i16);
+ println!("{:?}", f as i32);
+ println!("{:?}", f as i64);
+ println!("{:?}", f as u8);
+ println!("{:?}", f as u16);
+ println!("{:?}", f as u32);
+ println!("{:?}", f as u64);
+
+ println!("{:?}", 1 as int);
+ println!("{:?}", 1 as uint);
+ println!("{:?}", 1 as *const libc::FILE);
+ println!("{:?}", 1 as i8);
+ println!("{:?}", 1 as i16);
+ println!("{:?}", 1 as i32);
+ println!("{:?}", 1 as i64);
+ println!("{:?}", 1 as u8);
+ println!("{:?}", 1 as u16);
+ println!("{:?}", 1 as u32);
+ println!("{:?}", 1 as u64);
+ println!("{:?}", 1i as f32);
+ println!("{:?}", 1i as f64);
+
+ println!("{:?}", 1u as int);
+ println!("{:?}", 1u as uint);
+ println!("{:?}", 1u as *const libc::FILE);
+ println!("{:?}", 1u as i8);
+ println!("{:?}", 1u as i16);
+ println!("{:?}", 1u as i32);
+ println!("{:?}", 1u as i64);
+ println!("{:?}", 1u as u8);
+ println!("{:?}", 1u as u16);
+ println!("{:?}", 1u as u32);
+ println!("{:?}", 1u as u64);
+ println!("{:?}", 1u as f32);
+ println!("{:?}", 1u as f64);
+
+ println!("{:?}", 1i8 as int);
+ println!("{:?}", 1i8 as uint);
+ println!("{:?}", 1i8 as *const libc::FILE);
+ println!("{:?}", 1i8 as i8);
+ println!("{:?}", 1i8 as i16);
+ println!("{:?}", 1i8 as i32);
+ println!("{:?}", 1i8 as i64);
+ println!("{:?}", 1i8 as u8);
+ println!("{:?}", 1i8 as u16);
+ println!("{:?}", 1i8 as u32);
+ println!("{:?}", 1i8 as u64);
+ println!("{:?}", 1i8 as f32);
+ println!("{:?}", 1i8 as f64);
+
+ println!("{:?}", 1u8 as int);
+ println!("{:?}", 1u8 as uint);
+ println!("{:?}", 1u8 as *const libc::FILE);
+ println!("{:?}", 1u8 as i8);
+ println!("{:?}", 1u8 as i16);
+ println!("{:?}", 1u8 as i32);
+ println!("{:?}", 1u8 as i64);
+ println!("{:?}", 1u8 as u8);
+ println!("{:?}", 1u8 as u16);
+ println!("{:?}", 1u8 as u32);
+ println!("{:?}", 1u8 as u64);
+ println!("{:?}", 1u8 as f32);
+ println!("{:?}", 1u8 as f64);
+
+ println!("{:?}", 1i16 as int);
+ println!("{:?}", 1i16 as uint);
+ println!("{:?}", 1i16 as *const libc::FILE);
+ println!("{:?}", 1i16 as i8);
+ println!("{:?}", 1i16 as i16);
+ println!("{:?}", 1i16 as i32);
+ println!("{:?}", 1i16 as i64);
+ println!("{:?}", 1i16 as u8);
+ println!("{:?}", 1i16 as u16);
+ println!("{:?}", 1i16 as u32);
+ println!("{:?}", 1i16 as u64);
+ println!("{:?}", 1i16 as f32);
+ println!("{:?}", 1i16 as f64);
+
+ println!("{:?}", 1u16 as int);
+ println!("{:?}", 1u16 as uint);
+ println!("{:?}", 1u16 as *const libc::FILE);
+ println!("{:?}", 1u16 as i8);
+ println!("{:?}", 1u16 as i16);
+ println!("{:?}", 1u16 as i32);
+ println!("{:?}", 1u16 as i64);
+ println!("{:?}", 1u16 as u8);
+ println!("{:?}", 1u16 as u16);
+ println!("{:?}", 1u16 as u32);
+ println!("{:?}", 1u16 as u64);
+ println!("{:?}", 1u16 as f32);
+ println!("{:?}", 1u16 as f64);
+
+ println!("{:?}", 1i32 as int);
+ println!("{:?}", 1i32 as uint);
+ println!("{:?}", 1i32 as *const libc::FILE);
+ println!("{:?}", 1i32 as i8);
+ println!("{:?}", 1i32 as i16);
+ println!("{:?}", 1i32 as i32);
+ println!("{:?}", 1i32 as i64);
+ println!("{:?}", 1i32 as u8);
+ println!("{:?}", 1i32 as u16);
+ println!("{:?}", 1i32 as u32);
+ println!("{:?}", 1i32 as u64);
+ println!("{:?}", 1i32 as f32);
+ println!("{:?}", 1i32 as f64);
+
+ println!("{:?}", 1u32 as int);
+ println!("{:?}", 1u32 as uint);
+ println!("{:?}", 1u32 as *const libc::FILE);
+ println!("{:?}", 1u32 as i8);
+ println!("{:?}", 1u32 as i16);
+ println!("{:?}", 1u32 as i32);
+ println!("{:?}", 1u32 as i64);
+ println!("{:?}", 1u32 as u8);
+ println!("{:?}", 1u32 as u16);
+ println!("{:?}", 1u32 as u32);
+ println!("{:?}", 1u32 as u64);
+ println!("{:?}", 1u32 as f32);
+ println!("{:?}", 1u32 as f64);
+
+ println!("{:?}", 1i64 as int);
+ println!("{:?}", 1i64 as uint);
+ println!("{:?}", 1i64 as *const libc::FILE);
+ println!("{:?}", 1i64 as i8);
+ println!("{:?}", 1i64 as i16);
+ println!("{:?}", 1i64 as i32);
+ println!("{:?}", 1i64 as i64);
+ println!("{:?}", 1i64 as u8);
+ println!("{:?}", 1i64 as u16);
+ println!("{:?}", 1i64 as u32);
+ println!("{:?}", 1i64 as u64);
+ println!("{:?}", 1i64 as f32);
+ println!("{:?}", 1i64 as f64);
+
+ println!("{:?}", 1u64 as int);
+ println!("{:?}", 1u64 as uint);
+ println!("{:?}", 1u64 as *const libc::FILE);
+ println!("{:?}", 1u64 as i8);
+ println!("{:?}", 1u64 as i16);
+ println!("{:?}", 1u64 as i32);
+ println!("{:?}", 1u64 as i64);
+ println!("{:?}", 1u64 as u8);
+ println!("{:?}", 1u64 as u16);
+ println!("{:?}", 1u64 as u32);
+ println!("{:?}", 1u64 as u64);
+ println!("{:?}", 1u64 as f32);
+ println!("{:?}", 1u64 as f64);
+
+ println!("{:?}", 1u64 as int);
+ println!("{:?}", 1u64 as uint);
+ println!("{:?}", 1u64 as *const libc::FILE);
+ println!("{:?}", 1u64 as i8);
+ println!("{:?}", 1u64 as i16);
+ println!("{:?}", 1u64 as i32);
+ println!("{:?}", 1u64 as i64);
+ println!("{:?}", 1u64 as u8);
+ println!("{:?}", 1u64 as u16);
+ println!("{:?}", 1u64 as u32);
+ println!("{:?}", 1u64 as u64);
+ println!("{:?}", 1u64 as f32);
+ println!("{:?}", 1u64 as f64);
+
+ println!("{:?}", true as int);
+ println!("{:?}", true as uint);
+ println!("{:?}", true as *const libc::FILE);
+ println!("{:?}", true as i8);
+ println!("{:?}", true as i16);
+ println!("{:?}", true as i32);
+ println!("{:?}", true as i64);
+ println!("{:?}", true as u8);
+ println!("{:?}", true as u16);
+ println!("{:?}", true as u32);
+ println!("{:?}", true as u64);
+ println!("{:?}", true as f32);
+ println!("{:?}", true as f64);
+
+ println!("{:?}", 1f32 as int);
+ println!("{:?}", 1f32 as uint);
+ println!("{:?}", 1f32 as i8);
+ println!("{:?}", 1f32 as i16);
+ println!("{:?}", 1f32 as i32);
+ println!("{:?}", 1f32 as i64);
+ println!("{:?}", 1f32 as u8);
+ println!("{:?}", 1f32 as u16);
+ println!("{:?}", 1f32 as u32);
+ println!("{:?}", 1f32 as u64);
+ println!("{:?}", 1f32 as f32);
+ println!("{:?}", 1f32 as f64);
+
+ println!("{:?}", 1f64 as int);
+ println!("{:?}", 1f64 as uint);
+ println!("{:?}", 1f64 as i8);
+ println!("{:?}", 1f64 as i16);
+ println!("{:?}", 1f64 as i32);
+ println!("{:?}", 1f64 as i64);
+ println!("{:?}", 1f64 as u8);
+ println!("{:?}", 1f64 as u16);
+ println!("{:?}", 1f64 as u32);
+ println!("{:?}", 1f64 as u64);
+ println!("{:?}", 1f64 as f32);
+ println!("{:?}", 1f64 as f64);
}
#![feature(optin_builtin_traits)]
-use std::kinds::Send;
+use std::marker::Send;
struct TestType;
pub fn main() {
let x = t_rec {c8: 22u8, t: a_tag::a_tag_var(44u64)};
- let y = format!("{}", x);
- println!("y = {}", y);
- assert_eq!(y, "t_rec { c8: 22, t: a_tag_var(44) }".to_string());
+ let y = format!("{:?}", x);
+ println!("y = {:?}", y);
+ assert_eq!(y, "t_rec { c8: 22u8, t: a_tag_var(44u64) }".to_string());
}
}
pub fn main() {
- let act = format!("{}", color::red);
+ let act = format!("{:?}", color::red);
println!("{}", act);
assert_eq!("red".to_string(), act);
- assert_eq!("green".to_string(), format!("{}", color::green));
- assert_eq!("white".to_string(), format!("{}", color::white));
+ assert_eq!("green".to_string(), format!("{:?}", color::green));
+ assert_eq!("white".to_string(), format!("{:?}", color::white));
}
fn start() { println!("Started / Finished task."); }
fn test00() {
- let _ = Thread::spawn(move|| start() ).join();
+ let _ = Thread::scoped(move|| start() ).join();
println!("Completing.");
}
fn test00() {
let i: int = 0;
- let mut result = Thread::spawn(move|| {
+ let mut result = Thread::scoped(move|| {
start(i)
});
pub fn main() {
println!("Check that we don't deadlock.");
let (tx, rx) = channel();
- let _ = Thread::spawn(move|| { start(&tx, 0, 10) }).join();
+ let _ = Thread::scoped(move|| { start(&tx, 0, 10) }).join();
println!("Joined task");
}
while (i > 0) {
println!("{}", i);
let tx = tx.clone();
- Thread::spawn({let i = i; move|| { child(i, &tx) }}).detach();
+ Thread::spawn({let i = i; move|| { child(i, &tx) }});
i = i - 1;
}
}
pub fn main() {
- let _t = Thread::spawn(move|| f() ).join();
+ let _t = Thread::scoped(move|| f() ).join();
}
let mut results = Vec::new();
while i < number_of_tasks {
let tx = tx.clone();
- results.push(Thread::spawn({
+ results.push(Thread::scoped({
let i = i;
move|| {
test00_start(&tx, i, number_of_messages)
let (tx, rx) = channel();
let number_of_messages: int = 10;
- let result = Thread::spawn(move|| {
+ let result = Thread::scoped(move|| {
test00_start(&tx, number_of_messages);
});
let mut reader = ChanReader::new(rx);
let stderr = ChanWriter::new(tx);
- let res = thread::Builder::new().stderr(box stderr as Box<Writer + Send>).spawn(move|| -> () {
+ let res = thread::Builder::new().stderr(box stderr as Box<Writer + Send>).scoped(move|| -> () {
panic!("Hello, world!")
}).join();
assert!(res.is_err());
}
}
srv_tx.send(());
- }).detach();
+ });
}
for _ in range(0, N) {
let _s = TcpStream::connect(addr).unwrap();
}
cli_tx.send(());
- }).detach();
+ });
}
drop((cli_tx, srv_tx));
timer::sleep(Duration::milliseconds(30 * 1000));
println!("timed out!");
unsafe { libc::exit(1) }
- }).detach();
+ });
let (tx, rx) = channel();
Thread::spawn(move || -> () {
stream.read_byte();
stream.write(&[2]);
}
- }).detach();
+ });
let addr = rx.recv().unwrap();
let (tx, rx) = channel();
Err(e) => debug!("{}", e)
}
tx.send(()).unwrap();
- }).detach();
+ });
}
// Wait for all clients to exit, but don't wait for the server to exit. The
tx.send(tmp.path().clone()).unwrap();
panic!("panic to unwind past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
let path = rx.recv().unwrap();
assert!(!path.exists());
let _tmp = tmp;
panic!("panic to unwind past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
assert!(!path.exists());
let path;
let f = move|:| {
TempDir::new("test_rm_tempdir").unwrap()
};
- let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir");
+ let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
path = tmp.path().clone();
assert!(path.exists());
}
tmp.close();
panic!("panic when unwinding past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
let path = rx.recv().unwrap();
assert!(!path.exists());
tmp.close();
panic!("panic when unwinding past `tmp`");
};
- let _ = Thread::spawn(f).join();
+ let _ = Thread::scoped(f).join();
assert!(!path.exists());
let path;
let f = move|:| {
TempDir::new("test_rm_tempdir").unwrap()
};
- let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir");
+ let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
path = tmp.path().clone();
assert!(path.exists());
tmp.close();
}
pub fn dont_double_panic() {
- let r: Result<(), _> = Thread::spawn(move|| {
+ let r: Result<(), _> = Thread::scoped(move|| {
let tmpdir = TempDir::new("test").unwrap();
// Remove the temporary directory so that TempDir sees
// an error on drop
fn test_panic() {
fn f() { let _x: Box<int> = panic!(); }
- Thread::spawn(move|| f() ).join().err().unwrap();
+ Thread::scoped(move|| f() ).join().err().unwrap();
}
fn test_panic_indirect() {
fn f() -> ! { panic!(); }
fn g() { let _x: Box<int> = f(); }
- Thread::spawn(move|| g() ).join().err().unwrap();
+ Thread::scoped(move|| g() ).join().err().unwrap();
}
pub fn main() {
pub fn main() {
let mut i = 10;
while i > 0 {
- Thread::spawn({let i = i; move|| child(i)}).detach();
+ Thread::spawn({let i = i; move|| child(i)});
i = i - 1;
}
println!("main thread exiting");
let (tx, rx) = channel();
tx.send(42i);
let r = rx.recv();
- println!("{}", r);
+ println!("{:?}", r);
}
pub fn main() {
let x = Foo(1, 2);
- println!("{}", x);
+ println!("{:?}", x);
}
pub fn main() {
unsafe {
- assert_eq!((*get_tydesc::<int>()).name, "int");
- assert_eq!((*get_tydesc::<Foo<uint>>()).name, "Foo<uint>");
+ assert_eq!((*get_tydesc::<int>()).name, "isize");
+ assert_eq!((*get_tydesc::<Foo<uint>>()).name, "Foo<usize>");
}
}
let tx = tx.clone();
Thread::spawn(move|| {
child(&tx, i)
- }).detach();
+ });
expected += i;
}
}
pub fn main() {
- let x = Thread::spawn(move|| {
+ let x = Thread::scoped(move|| {
let _b = Foo;
}).join();
let v = main.clone();
- let _ = Thread::spawn(move|| {
+ let _ = Thread::scoped(move|| {
let mut v = v;
let mut panic_countdown = panic_countdown;
v.as_mut_slice().sort_by(|a, b| {
+++ /dev/null
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn equal<T>(_: &T, _: &T) -> bool where int : Eq {
- true
-}
-
-fn main() {
- equal(&0i, &0i);
-}
use std::thread::Thread;
pub fn main() {
- let mut result = Thread::spawn(child);
+ let mut result = Thread::scoped(child);
println!("1");
Thread::yield_now();
println!("2");
use std::thread::Thread;
pub fn main() {
- let mut result = Thread::spawn(child);
+ let mut result = Thread::scoped(child);
println!("1");
Thread::yield_now();
result.join();
projects / rust.git / commitdiff