+276 -155

compiler-core/src/docs/printer.rs

View file Reviewed

··· 7 7 }; 8 8 9 9 use ecow::{EcoString, eco_format}; 10 10 - use itertools::Itertools; 11 10 12 11 use crate::{ 13 12 ast::{ 14 13 ArgNames, CustomType, Function, Publicity, RecordConstructorArg, SrcSpan, TypeAlias, 15 14 TypedArg, TypedDefinitions, TypedModuleConstant, TypedRecordConstructor, 16 15 }, 17 17 - docvec, 18 18 - pretty::{Document, Documentable, break_, join, line, nil, zero_width_string}, 19 16 type_::{ 20 17 Deprecation, PRELUDE_MODULE_NAME, PRELUDE_PACKAGE_NAME, Type, TypeVar, 21 18 printer::{Names, PrintMode}, 22 19 }, 23 20 }; 21 21 + use pretty_arena::*; 24 22 25 23 use super::{ 26 24 Dependency, DependencyKind, DocsValues, TypeConstructor, TypeConstructorArg, TypeDefinition, ··· 62 60 dependencies: &'a HashMap<EcoString, Dependency>, 63 61 } 64 62 65 65 - impl Printer<'_> { 66 66 - pub fn new<'a>( 63 63 + impl<'a, 'doc> Printer<'a> { 64 64 + pub fn new( 67 65 package: EcoString, 68 66 module: EcoString, 69 67 names: &'a Names, ··· 88 86 self.options = options; 89 87 } 90 88 91 91 - pub fn type_definitions<'a>( 89 89 + pub fn type_definitions( 92 90 &mut self, 93 91 source_links: &SourceLinker, 94 92 definitions: &'a TypedDefinitions, 95 93 ) -> Vec<TypeDefinition<'a>> { 96 94 let mut type_definitions = vec![]; 95 95 + let arena = DocumentArena::new(); 97 96 98 97 for CustomType { 99 98 location, ··· 113 112 114 113 type_definitions.push(TypeDefinition { 115 114 name, 116 116 - definition: print(self.custom_type(name, parameters, constructors, *opaque)), 115 115 + definition: print(self.custom_type( 116 116 + &arena, 117 117 + name, 118 118 + parameters, 119 119 + constructors, 120 120 + *opaque, 121 121 + )), 117 122 raw_definition: self 118 118 - .raw(|this| this.custom_type(name, parameters, constructors, *opaque)), 123 123 + .raw(|this| this.custom_type(&arena, name, parameters, constructors, *opaque)), 119 124 documentation: markdown_documentation(documentation), 120 125 text_documentation: text_documentation(documentation), 121 126 deprecation_message: match deprecation { ··· 128 133 constructors 129 134 .iter() 130 135 .map(|constructor| TypeConstructor { 131 131 - definition: print(self.record_constructor(constructor)), 132 132 - raw_definition: self.raw(|this| this.record_constructor(constructor)), 136 136 + definition: print(self.record_constructor(&arena, constructor)), 137 137 + raw_definition: self 138 138 + .raw(|this| this.record_constructor(&arena, constructor)), 133 139 documentation: markdown_documentation(&constructor.documentation), 134 140 text_documentation: text_documentation(&constructor.documentation), 135 141 arguments: constructor ··· 167 173 } 168 174 type_definitions.push(TypeDefinition { 169 175 name, 170 170 - definition: print(self.type_alias(name, type_, parameters).group()), 171 171 - raw_definition: self.raw(|this| this.type_alias(name, type_, parameters).group()), 176 176 + definition: print( 177 177 + self.type_alias(&arena, name, type_, parameters) 178 178 + .group(&arena), 179 179 + ), 180 180 + raw_definition: self.raw(|this| { 181 181 + this.type_alias(&arena, name, type_, parameters) 182 182 + .group(&arena) 183 183 + }), 172 184 documentation: markdown_documentation(documentation), 173 185 text_documentation: text_documentation(documentation), 174 186 constructors: vec![], ··· 186 198 } 187 199 188 200 /// Print a definition without HTML highlighting, such as for search data 189 189 - fn raw<'a, F>(&mut self, definition: F) -> String 190 190 - where 191 191 - F: FnOnce(&mut Self) -> Document<'a>, 192 192 - { 201 201 + fn raw<'doc1, 'a1: 'doc1>( 202 202 + &mut self, 203 203 + definition: impl FnOnce(&mut Self) -> Document<'a1, 'doc1>, 204 204 + ) -> String { 193 205 let options = self.options; 194 206 // Turn off highlighting for this definition 195 207 self.options = PrintOptions { ··· 202 214 format!("```\n{result}\n```") 203 215 } 204 216 205 205 - pub fn value_definitions<'a>( 217 217 + pub fn value_definitions( 206 218 &mut self, 207 219 source_links: &SourceLinker, 208 220 definitions: &'a TypedDefinitions, 209 221 ) -> Vec<DocsValues<'a>> { 210 222 let mut value_definitions = vec![]; 223 223 + let arena = DocumentArena::new(); 211 224 212 225 for Function { 213 226 location, ··· 233 246 234 247 value_definitions.push(DocsValues { 235 248 name, 236 236 - definition: print(self.function_signature(name, arguments, return_type)), 249 249 + definition: print(self.function_signature(&arena, name, arguments, return_type)), 237 250 raw_definition: self 238 238 - .raw(|this| this.function_signature(name, arguments, return_type)), 251 251 + .raw(|this| this.function_signature(&arena, name, arguments, return_type)), 239 252 documentation: markdown_documentation(documentation), 240 253 text_documentation: text_documentation(documentation), 241 254 source_url: source_links.url(*location), ··· 262 275 263 276 value_definitions.push(DocsValues { 264 277 name, 265 265 - definition: print(self.constant(name, type_)), 266 266 - raw_definition: self.raw(|this| this.constant(name, type_)), 278 278 + definition: print(self.constant(&arena, name, type_)), 279 279 + raw_definition: self.raw(|this| this.constant(&arena, name, type_)), 267 280 documentation: markdown_documentation(documentation), 268 281 text_documentation: text_documentation(documentation), 269 282 source_url: source_links.url(*location), ··· 278 291 value_definitions 279 292 } 280 293 281 281 - fn custom_type<'a>( 294 294 + fn custom_type( 282 295 &mut self, 296 296 + arena: &'doc DocumentArena<'a, 'doc>, 283 297 name: &'a str, 284 298 parameters: &'a [(SrcSpan, EcoString)], 285 299 constructors: &'a [TypedRecordConstructor], 286 300 opaque: bool, 287 287 - ) -> Document<'a> { 301 301 + ) -> Document<'a, 'doc> { 288 302 let arguments = if parameters.is_empty() { 289 289 - nil() 303 303 + EMPTY_DOCUMENT 290 304 } else { 291 305 Self::wrap_arguments( 306 306 + arena, 292 307 parameters 293 308 .iter() 294 294 - .map(|(_, parameter)| self.variable(parameter)), 309 309 + .map(|(_, parameter)| self.variable(arena, parameter)), 295 310 ) 296 311 }; 297 312 298 298 - let keywords = if opaque { 299 299 - "pub opaque type " 300 300 - } else { 301 301 - "pub type " 302 302 - }; 303 303 - 304 304 - let type_head = docvec![self.keyword(keywords), self.title(name), arguments]; 313 313 + let type_head = docvec![ 314 314 + arena, 315 315 + self.keyword( 316 316 + arena, 317 317 + if opaque { 318 318 + PUB_OPAQUE_TYPE_SPACE_DOCUMENT 319 319 + } else { 320 320 + PUB_TYPE_SPACE_DOCUMENT 321 321 + } 322 322 + ), 323 323 + self.title(arena, name), 324 324 + arguments 325 325 + ]; 305 326 306 327 if constructors.is_empty() || opaque { 307 328 return type_head; 308 329 } 309 330 310 310 - let constructors = constructors 311 311 - .iter() 312 312 - .map(|constructor| { 313 313 - line() 314 314 - .append(self.record_constructor(constructor)) 315 315 - .nest(INDENT) 316 316 - }) 317 317 - .collect_vec(); 331 331 + let constructors = arena.concat(constructors.iter().map(|constructor| { 332 332 + LINE_DOCUMENT 333 333 + .append(arena, self.record_constructor(arena, constructor)) 334 334 + .nest(arena, INDENT) 335 335 + })); 318 336 319 319 - docvec![type_head, " {", constructors, line(), "}"] 337 337 + docvec![ 338 338 + arena, 339 339 + type_head, 340 340 + SPACE_OPEN_CURLY_DOCUMENT, 341 341 + constructors, 342 342 + LINE_DOCUMENT, 343 343 + CLOSE_CURLY_DOCUMENT 344 344 + ] 320 345 } 321 346 322 322 - pub fn record_constructor<'a>( 347 347 + pub fn record_constructor( 323 348 &mut self, 349 349 + arena: &'doc DocumentArena<'a, 'doc>, 324 350 constructor: &'a TypedRecordConstructor, 325 325 - ) -> Document<'a> { 351 351 + ) -> Document<'a, 'doc> { 326 352 if constructor.arguments.is_empty() { 327 327 - return self.title(&constructor.name); 353 353 + return self.title(arena, &constructor.name); 328 354 } 329 355 330 356 let arguments = constructor.arguments.iter().map( 331 357 |RecordConstructorArg { label, type_, .. }| match label { 332 358 Some((_, label)) => self 333 333 - .variable(label) 334 334 - .append(": ") 335 335 - .append(self.type_(type_, PrintMode::Normal)), 336 336 - None => self.type_(type_, PrintMode::Normal), 359 359 + .variable(arena, label) 360 360 + .append(arena, COLON_SPACE_DOCUMENT) 361 361 + .append(arena, self.type_(arena, type_, PrintMode::Normal)), 362 362 + None => self.type_(arena, type_, PrintMode::Normal), 337 363 }, 338 364 ); 339 365 340 340 - let arguments = Self::wrap_arguments(arguments); 366 366 + let arguments = Self::wrap_arguments(arena, arguments); 341 367 342 342 - docvec![self.title(&constructor.name), arguments].group() 368 368 + docvec![arena, self.title(arena, &constructor.name), arguments].group(arena) 343 369 } 344 370 345 345 - fn type_alias<'a>( 371 371 + fn type_alias( 346 372 &mut self, 373 373 + arena: &'doc DocumentArena<'a, 'doc>, 347 374 name: &'a str, 348 375 type_: &Type, 349 376 parameters: &[(SrcSpan, EcoString)], 350 350 - ) -> Document<'a> { 377 377 + ) -> Document<'a, 'doc> { 351 378 let parameters = if parameters.is_empty() { 352 352 - nil() 379 379 + EMPTY_DOCUMENT 353 380 } else { 354 381 let arguments = parameters 355 382 .iter() 356 356 - .map(|(_, parameter)| self.variable(parameter)); 357 357 - Self::wrap_arguments(arguments) 383 383 + .map(|(_, parameter)| self.variable(arena, parameter)); 384 384 + Self::wrap_arguments(arena, arguments) 358 385 }; 359 386 360 387 docvec![ 361 361 - self.keyword("pub type "), 362 362 - self.title(name), 388 388 + arena, 389 389 + self.keyword(arena, PUB_TYPE_SPACE_DOCUMENT), 390 390 + self.title(arena, name), 363 391 parameters, 364 364 - " =", 365 365 - line() 366 366 - .append(self.type_(type_, PrintMode::ExpandAliases)) 367 367 - .nest(INDENT) 392 392 + SPACE_EQUAL_DOCUMENT, 393 393 + LINE_DOCUMENT 394 394 + .append(arena, self.type_(arena, type_, PrintMode::ExpandAliases)) 395 395 + .nest(arena, INDENT) 368 396 ] 369 397 } 370 398 371 371 - fn constant<'a>(&mut self, name: &'a str, type_: &Type) -> Document<'a> { 399 399 + fn constant( 400 400 + &mut self, 401 401 + arena: &'doc DocumentArena<'a, 'doc>, 402 402 + name: &'a str, 403 403 + type_: &Type, 404 404 + ) -> Document<'a, 'doc> { 372 405 self.register_local_type_variable_names(type_); 373 406 374 407 docvec![ 375 375 - self.keyword("pub const "), 376 376 - self.title(name), 377 377 - ": ", 378 378 - self.type_(type_, PrintMode::Normal) 408 408 + arena, 409 409 + self.keyword(arena, PUB_CONST_SPACE_DOCUMENT), 410 410 + self.title(arena, name), 411 411 + COLON_SPACE_DOCUMENT, 412 412 + self.type_(arena, type_, PrintMode::Normal) 379 413 ] 380 414 } 381 415 382 382 - fn function_signature<'a>( 416 416 + fn function_signature( 383 417 &mut self, 418 418 + arena: &'doc DocumentArena<'a, 'doc>, 384 419 name: &'a str, 385 420 arguments: &'a [TypedArg], 386 421 return_type: &Type, 387 387 - ) -> Document<'a> { 422 422 + ) -> Document<'a, 'doc> { 388 423 for argument in arguments { 389 424 self.register_local_type_variable_names(&argument.type_); 390 425 } 391 426 self.register_local_type_variable_names(return_type); 392 427 393 428 let arguments = if arguments.is_empty() { 394 394 - "()".to_doc() 429 429 + OPEN_CLOSE_PAREN_DOCUMENT 395 430 } else { 396 396 - Self::wrap_arguments(arguments.iter().map(|argument| { 397 397 - let name = self.variable(self.argument_name(argument)); 398 398 - docvec![name, ": ", self.type_(&argument.type_, PrintMode::Normal)].group() 399 399 - })) 431 431 + Self::wrap_arguments( 432 432 + arena, 433 433 + arguments.iter().map(|argument| { 434 434 + let name = self.variable(arena, self.argument_name(arena, argument)); 435 435 + docvec![ 436 436 + arena, 437 437 + name, 438 438 + COLON_SPACE_DOCUMENT, 439 439 + self.type_(arena, &argument.type_, PrintMode::Normal) 440 440 + ] 441 441 + .group(arena) 442 442 + }), 443 443 + ) 400 444 }; 401 445 402 446 docvec![ 403 403 - self.keyword("pub fn "), 404 404 - self.title(name), 447 447 + arena, 448 448 + self.keyword(arena, PUB_FN_SPACE_DOCUMENT), 449 449 + self.title(arena, name), 405 450 arguments, 406 406 - " -> ", 407 407 - self.type_(return_type, PrintMode::Normal) 451 451 + SPACE_RIGHT_ARROW_SPACE_DOCUMENT, 452 452 + self.type_(arena, return_type, PrintMode::Normal) 408 453 ] 409 409 - .group() 454 454 + .group(arena) 410 455 } 411 456 412 412 - fn argument_name<'a>(&self, arg: &'a TypedArg) -> Document<'a> { 457 457 + fn argument_name( 458 458 + &self, 459 459 + arena: &'doc DocumentArena<'a, 'doc>, 460 460 + arg: &'a TypedArg, 461 461 + ) -> Document<'a, 'doc> { 413 462 match &arg.names { 414 414 - ArgNames::Named { name, .. } => name.to_doc(), 415 415 - ArgNames::NamedLabelled { label, name, .. } => docvec![label, " ", name], 463 463 + ArgNames::Named { name, .. } => name.to_doc(arena), 464 464 + ArgNames::NamedLabelled { label, name, .. } => { 465 465 + docvec![arena, label, SPACE_DOCUMENT, name] 466 466 + } 416 467 // We remove the underscore from discarded function arguments since we don't want to 417 468 // expose this kind of detail: https://github.com/gleam-lang/gleam/issues/2561 418 469 ArgNames::Discard { name, .. } => match name.strip_prefix('_').unwrap_or(name) { 419 419 - "" => "arg".to_doc(), 420 420 - name => name.to_doc(), 470 470 + "" => LOWERCASE_ARG_DOCUMENT, 471 471 + name => name.to_doc(arena), 421 472 }, 422 473 ArgNames::LabelledDiscard { label, name, .. } => { 423 423 - docvec![label, " ", name.strip_prefix('_').unwrap_or(name).to_doc()] 474 474 + docvec![ 475 475 + arena, 476 476 + label, 477 477 + SPACE_DOCUMENT, 478 478 + name.strip_prefix('_').unwrap_or(name).to_doc(arena) 479 479 + ] 424 480 } 425 481 } 426 482 } 427 483 428 428 - fn wrap_arguments<'a>(arguments: impl IntoIterator<Item = Document<'a>>) -> Document<'a> { 429 429 - break_("(", "(") 430 430 - .append(join(arguments, break_(",", ", "))) 431 431 - .nest_if_broken(INDENT) 432 432 - .append(break_(",", "")) 433 433 - .append(")") 484 484 + fn wrap_arguments( 485 485 + arena: &'doc DocumentArena<'a, 'doc>, 486 486 + arguments: impl IntoIterator<Item = Document<'a, 'doc>>, 487 487 + ) -> Document<'a, 'doc> { 488 488 + OPEN_PAREN_BREAK_DOCUMENT 489 489 + .append(arena, arena.join(arguments, COMMA_BREAK_DOCUMENT)) 490 490 + .nest_if_broken(arena, INDENT) 491 491 + .append(arena, TRAILING_COMMA_BREAK_DOCUMENT) 492 492 + .append(arena, CLOSE_PAREN_DOCUMENT) 434 493 } 435 494 436 436 - fn type_arguments<'a>(arguments: impl IntoIterator<Item = Document<'a>>) -> Document<'a> { 437 437 - break_("", "") 438 438 - .append(join(arguments, break_(",", ", "))) 439 439 - .nest_if_broken(INDENT) 440 440 - .append(break_(",", "")) 441 441 - .group() 442 442 - .surround("(", ")") 495 495 + fn type_arguments( 496 496 + arena: &'doc DocumentArena<'a, 'doc>, 497 497 + arguments: impl IntoIterator<Item = Document<'a, 'doc>>, 498 498 + ) -> Document<'a, 'doc> { 499 499 + EMPTY_BREAK_DOCUMENT 500 500 + .append(arena, arena.join(arguments, COMMA_BREAK_DOCUMENT)) 501 501 + .nest_if_broken(arena, INDENT) 502 502 + .append(arena, TRAILING_COMMA_BREAK_DOCUMENT) 503 503 + .group(arena) 504 504 + .surround(arena, OPEN_PAREN_DOCUMENT, CLOSE_PAREN_DOCUMENT) 443 505 } 444 506 445 445 - fn type_(&mut self, type_: &Type, print_mode: PrintMode) -> Document<'static> { 507 507 + fn type_( 508 508 + &mut self, 509 509 + arena: &'doc DocumentArena<'a, 'doc>, 510 510 + type_: &Type, 511 511 + print_mode: PrintMode, 512 512 + ) -> Document<'a, 'doc> { 446 513 match type_ { 447 514 Type::Named { 448 515 package, ··· 458 525 // is aliasing that internal type, rather than showing it as 459 526 // aliasing itself. 460 527 PrintMode::ExpandAliases if *package == self.package => { 461 461 - self.named_type_name(publicity, package, module, name) 528 528 + self.named_type_name(arena, publicity, package, module, name) 462 529 } 463 530 // If we are printing a type alias which aliases an internal 464 531 // type from a different package, we still want to print the ··· 471 538 if let Some((module, alias)) = 472 539 self.names.reexport_alias(module.clone(), name.clone()) 473 540 { 474 474 - self.named_type_name(&Publicity::Public, package, module, alias) 541 541 + self.named_type_name(arena, &Publicity::Public, package, module, alias) 475 542 } else { 476 476 - self.named_type_name(publicity, package, module, name) 543 543 + self.named_type_name(arena, publicity, package, module, name) 477 544 } 478 545 } 479 546 }; ··· 481 548 if arguments.is_empty() { 482 549 name 483 550 } else { 484 484 - name.append(Self::type_arguments( 485 485 - arguments 486 486 - .iter() 487 487 - .map(|argument| self.type_(argument, PrintMode::Normal)), 488 488 - )) 551 551 + name.append( 552 552 + arena, 553 553 + Self::type_arguments( 554 554 + arena, 555 555 + arguments 556 556 + .iter() 557 557 + .map(|argument| self.type_(arena, argument, PrintMode::Normal)), 558 558 + ), 559 559 + ) 489 560 } 490 561 } 491 562 Type::Fn { arguments, return_ } => docvec![ 492 492 - self.keyword("fn"), 563 563 + arena, 564 564 + self.keyword(arena, FN_DOCUMENT), 493 565 Self::type_arguments( 566 566 + arena, 494 567 arguments 495 568 .iter() 496 496 - .map(|argument| self.type_(argument, PrintMode::Normal)) 569 569 + .map(|argument| self.type_(arena, argument, PrintMode::Normal)) 497 570 ), 498 498 - " -> ", 499 499 - self.type_(return_, PrintMode::Normal) 571 571 + SPACE_RIGHT_ARROW_SPACE_DOCUMENT, 572 572 + self.type_(arena, return_, PrintMode::Normal) 500 573 ], 501 574 Type::Tuple { elements } => docvec![ 502 502 - "#", 575 575 + arena, 576 576 + HASHTAG_DOCUMENT, 503 577 Self::type_arguments( 578 578 + arena, 504 579 elements 505 580 .iter() 506 506 - .map(|element| self.type_(element, PrintMode::Normal)) 581 581 + .map(|element| self.type_(arena, element, PrintMode::Normal)) 507 582 ), 508 583 ], 509 584 Type::Var { type_ } => match type_.as_ref().borrow().deref() { 510 510 - TypeVar::Link { type_ } => self.type_(type_, PrintMode::Normal), 585 585 + TypeVar::Link { type_ } => self.type_(arena, type_, PrintMode::Normal), 511 586 512 587 TypeVar::Unbound { id } | TypeVar::Generic { id } => { 513 588 let name = self.type_variable(*id); 514 514 - self.variable(name) 589 589 + self.variable(arena, name) 515 590 } 516 591 }, 517 592 } ··· 561 636 562 637 fn named_type_name( 563 638 &self, 639 639 + arena: &'doc DocumentArena<'a, 'doc>, 564 640 publicity: &Publicity, 565 641 package: &str, 566 642 module: &str, 567 643 name: &EcoString, 568 568 - ) -> Document<'static> { 644 644 + ) -> Document<'a, 'doc> { 569 645 // There's no documentation page for the prelude 570 646 if package == PRELUDE_PACKAGE_NAME && module == PRELUDE_MODULE_NAME { 571 571 - return self.title(name); 647 647 + return self.title(arena, name); 572 648 } 573 649 574 650 // Internal types don't get linked 575 651 if !publicity.is_public() { 576 576 - return docvec![self.comment("@internal ".to_doc()), self.title(name)]; 652 652 + return docvec![ 653 653 + arena, 654 654 + self.comment(arena, INTERNAL_ATTRIBUTE_SPACE_DOCUMENT), 655 655 + self.title(arena, name) 656 656 + ]; 577 657 } 578 658 579 659 // Linking to a type within the same page 580 660 if package == self.package && module == self.module { 581 581 - return self.link(eco_format!("#{name}"), self.title(name), None); 661 661 + return self.link(arena, eco_format!("#{name}"), self.title(arena, name), None); 582 662 } 583 663 584 664 // Linking to a module within the package ··· 622 702 path.push(module_name); 623 703 624 704 let qualified_name = docvec![ 625 625 - self.variable(EcoString::from(module_name)), 626 626 - ".", 627 627 - self.title(name) 705 705 + arena, 706 706 + self.variable(arena, EcoString::from(module_name)), 707 707 + DOT_DOCUMENT, 708 708 + self.title(arena, name) 628 709 ]; 629 710 630 711 let title = eco_format!("{module}.{{type {name}}}"); 631 712 632 713 return self.link( 714 714 + arena, 633 715 eco_format!("{path}.html#{name}", path = path.join("/")), 634 716 qualified_name, 635 717 Some(title), ··· 638 720 639 721 let module_name = module.split('/').next_back().unwrap_or(module); 640 722 let qualified_name = docvec![ 641 641 - self.variable(EcoString::from(module_name)), 642 642 - ".", 643 643 - self.title(name) 723 723 + arena, 724 724 + self.variable(arena, EcoString::from(module_name)), 725 725 + DOT_DOCUMENT, 726 726 + self.title(arena, name) 644 727 ]; 645 728 let title = eco_format!("{module}.{{type {name}}}"); 646 729 ··· 651 734 kind: DependencyKind::Hex, 652 735 version, 653 736 }) => self.link( 737 737 + arena, 654 738 eco_format!( 655 739 "https://{package}.hexdocs.pm/{version}/{module}.html#{name}", 656 740 package = package.replace('_', "-") ··· 658 742 qualified_name, 659 743 Some(title), 660 744 ), 661 661 - Some(_) | None => self.span_with_title(qualified_name, title), 745 745 + Some(_) | None => self.span_with_title(arena, qualified_name, title), 662 746 } 663 747 } 664 748 ··· 705 789 } 706 790 } 707 791 708 708 - fn keyword<'a>(&self, keyword: impl Documentable<'a>) -> Document<'a> { 709 709 - self.colour_span(keyword, "keyword") 792 792 + fn keyword( 793 793 + &self, 794 794 + arena: &'doc DocumentArena<'a, 'doc>, 795 795 + keyword: Document<'static, 'static>, 796 796 + ) -> Document<'a, 'doc> { 797 797 + self.colour_span(arena, keyword, ColourClass::Keyword) 710 798 } 711 799 712 712 - fn comment<'a>(&self, name: impl Documentable<'a>) -> Document<'a> { 713 713 - self.colour_span(name, "comment") 800 800 + fn comment( 801 801 + &self, 802 802 + arena: &'doc DocumentArena<'a, 'doc>, 803 803 + name: impl Documentable<'a, 'doc>, 804 804 + ) -> Document<'a, 'doc> { 805 805 + self.colour_span(arena, name, ColourClass::Comment) 714 806 } 715 807 716 716 - fn title<'a>(&self, name: impl Documentable<'a>) -> Document<'a> { 717 717 - self.colour_span(name, "title") 808 808 + fn title( 809 809 + &self, 810 810 + arena: &'doc DocumentArena<'a, 'doc>, 811 811 + name: impl Documentable<'a, 'doc>, 812 812 + ) -> Document<'a, 'doc> { 813 813 + self.colour_span(arena, name, ColourClass::Title) 718 814 } 719 815 720 720 - fn variable<'a>(&self, name: impl Documentable<'a>) -> Document<'a> { 721 721 - self.colour_span(name, "variable") 816 816 + fn variable( 817 817 + &self, 818 818 + arena: &'doc DocumentArena<'a, 'doc>, 819 819 + name: impl Documentable<'a, 'doc>, 820 820 + ) -> Document<'a, 'doc> { 821 821 + self.colour_span(arena, name, ColourClass::Variable) 722 822 } 723 823 724 724 - fn colour_span<'a>( 824 824 + fn colour_span( 725 825 &self, 726 726 - name: impl Documentable<'a>, 727 727 - colour_class: &'static str, 728 728 - ) -> Document<'a> { 826 826 + arena: &'doc DocumentArena<'a, 'doc>, 827 827 + name: impl Documentable<'a, 'doc>, 828 828 + colour_class: ColourClass, 829 829 + ) -> Document<'a, 'doc> { 729 830 if !self.options.print_highlighting { 730 730 - return name.to_doc(); 831 831 + return name.to_doc(arena); 731 832 } 732 833 733 733 - name.to_doc().surround( 734 734 - zero_width_string(eco_format!(r#"<span class="hljs-{colour_class}">"#)), 735 735 - zero_width_string("</span>".into()), 736 736 - ) 834 834 + let open_tag = match colour_class { 835 835 + ColourClass::Variable => ZERO_WIDTH_OPEN_VARIABLE_COLOUR_SPAN, 836 836 + ColourClass::Title => ZERO_WIDTH_OPEN_TITLE_COLOUR_SPAN, 837 837 + ColourClass::Keyword => ZERO_WIDTH_OPEN_KEYWORD_COLOUR_SPAN, 838 838 + ColourClass::Comment => ZERO_WIDTH_OPEN_COMMENT_COLOUR_SPAN, 839 839 + }; 840 840 + 841 841 + name.to_doc(arena) 842 842 + .surround(arena, open_tag, ZERO_WIDTH_CLOSED_SPAN_TAG_DOCUMENT) 737 843 } 738 844 739 739 - fn link<'a>( 845 845 + fn link( 740 846 &self, 847 847 + arena: &'doc DocumentArena<'a, 'doc>, 741 848 href: EcoString, 742 742 - name: impl Documentable<'a>, 849 849 + name: impl Documentable<'a, 'doc>, 743 850 title: Option<EcoString>, 744 744 - ) -> Document<'a> { 851 851 + ) -> Document<'a, 'doc> { 745 852 if !self.options.print_html { 746 746 - return name.to_doc(); 853 853 + return name.to_doc(arena); 747 854 } 748 855 749 856 let opening_tag = if let Some(title) = title { ··· 752 859 eco_format!(r#"<a href="{href}">"#) 753 860 }; 754 861 755 755 - name.to_doc().surround( 756 756 - zero_width_string(opening_tag), 757 757 - zero_width_string("</a>".into()), 862 862 + name.to_doc(arena).surround( 863 863 + arena, 864 864 + arena.zero_width_string(opening_tag), 865 865 + ZERO_WIDTH_CLOSED_A_TAG_DOCUMENT, 758 866 ) 759 867 } 760 868 761 761 - fn span_with_title<'a>(&self, name: impl Documentable<'a>, title: EcoString) -> Document<'a> { 869 869 + fn span_with_title( 870 870 + &self, 871 871 + arena: &'doc DocumentArena<'a, 'doc>, 872 872 + name: impl Documentable<'a, 'doc>, 873 873 + title: EcoString, 874 874 + ) -> Document<'a, 'doc> { 762 875 if !self.options.print_html { 763 763 - return name.to_doc(); 876 876 + return name.to_doc(arena); 764 877 } 765 878 766 766 - name.to_doc().surround( 767 767 - zero_width_string(eco_format!(r#"<span title="{title}">"#)), 768 768 - zero_width_string("</span>".into()), 879 879 + name.to_doc(arena).surround( 880 880 + arena, 881 881 + arena.zero_width_string(eco_format!(r#"<span title="{title}">"#)), 882 882 + ZERO_WIDTH_CLOSED_SPAN_TAG_DOCUMENT, 769 883 ) 770 884 } 771 885 } 772 886 887 887 + enum ColourClass { 888 888 + Variable, 889 889 + Title, 890 890 + Keyword, 891 891 + Comment, 892 892 + } 893 893 + 773 894 const MAX_COLUMNS: isize = 65; 774 895 const INDENT: isize = 2; 775 896 776 776 - fn print(doc: Document<'_>) -> String { 897 897 + fn print<'a, 'doc>(doc: Document<'a, 'doc>) -> String { 777 898 doc.to_pretty_string(MAX_COLUMNS) 778 899 }

+44

pretty-arena/src/lib.rs

View file Reviewed

··· 201 201 | PrintableDocument::Str { .. } 202 202 | PrintableDocument::EcoString { .. } 203 203 | PrintableDocument::ZeroWidthString { .. } 204 204 + | PrintableDocument::ZeroWidthStr { .. } 204 205 | PrintableDocument::CursorPositionObserver { .. } => self, 205 206 206 207 PrintableDocument::Line(_) ··· 316 317 | PrintableDocument::Str { .. } 317 318 | PrintableDocument::EcoString { .. } 318 319 | PrintableDocument::ZeroWidthString { .. } 320 320 + | PrintableDocument::ZeroWidthStr { .. } 319 321 | PrintableDocument::CursorPositionObserver { .. } => { 320 322 Document(arena.documents.alloc(PrintableDocument::Join(self, new))) 321 323 } ··· 360 362 // still printed and so are not empty. (Unless their string contents 361 363 // is also empty) 362 364 PrintableDocument::ZeroWidthString { string } => string.is_empty(), 365 365 + PrintableDocument::ZeroWidthStr { string } => string.is_empty(), 363 366 PrintableDocument::CursorPositionObserver { .. } => true, 364 367 } 365 368 } ··· 477 480 /// in the final output, such as ANSI codes or HTML elements. 478 481 ZeroWidthString { 479 482 string: EcoString, 483 483 + }, 484 484 + ZeroWidthStr { 485 485 + string: &'string str, 480 486 }, 481 487 482 488 /// A node that gets notified of the cursor position as it is being formatted. ··· 551 557 /// wubble" 552 558 Set, 553 559 } 560 560 + 554 561 macro_rules! const_str { 555 562 ($name:ident, $string:expr, $graphemes:expr) => { 556 563 pub const $name: $crate::Document<'static, 'static> = { ··· 562 569 }; 563 570 } 564 571 572 572 + macro_rules! const_zero_width_str { 573 573 + ($name:ident, $string:expr) => { 574 574 + pub const $name: $crate::Document<'static, 'static> = 575 575 + { $crate::Document(&$crate::PrintableDocument::ZeroWidthStr { string: $string }) }; 576 576 + }; 577 577 + } 578 578 + 565 579 macro_rules! const_break { 566 580 ($name:ident, $broken:expr, $unbroken:expr) => { 567 581 pub const $name: $crate::Document<'static, 'static> = { ··· 700 714 ); 701 715 const_str!(QUOTE_COMMA_SPACE_QUOTE_DOCUMENT, "\", \"", 4); 702 716 const_str!(INTERNAL_ATTRIBUTE_DOCUMENT, "@internal", 9); 717 717 + const_str!(INTERNAL_ATTRIBUTE_SPACE_DOCUMENT, "@internal ", 9); 703 718 const_str!(TRUE_LOWERCASE_DOCUMENT, "true", 4); 704 719 const_str!(FALSE_LOWERCASE_DOCUMENT, "false", 5); 705 720 const_str!(OPEN_CLOSE_CURLY_DOCUMENT, "{}", 2); ··· 914 929 const_str!(SPACE_GT_EQ_INT_SPACE_DOCUMENT, " >= ", 4); 915 930 const_str!(CAMEL_CASE_REMAINDER_INT_DOCUMENT, "remainderInt", 12); 916 931 const_str!(PURE_JAVASCRIPT_COMMENT_DOCUMENT, "/* @__PURE__ */ ", 16); 932 932 + const_str!(LOWERCASE_ARG_DOCUMENT, "arg", 3); 933 933 + const_str!(PUB_TYPE_SPACE_DOCUMENT, "pub type ", 9); 934 934 + const_str!(PUB_FN_SPACE_DOCUMENT, "pub fn ", 7); 935 935 + const_str!(PUB_CONST_SPACE_DOCUMENT, "pub const ", 10); 936 936 + const_str!(PUB_OPAQUE_TYPE_SPACE_DOCUMENT, "pub opaque type ", 16); 937 937 + 938 938 + const_zero_width_str!(ZERO_WIDTH_CLOSED_SPAN_TAG_DOCUMENT, "</span>"); 939 939 + const_zero_width_str!(ZERO_WIDTH_CLOSED_A_TAG_DOCUMENT, "</a>"); 940 940 + const_zero_width_str!( 941 941 + ZERO_WIDTH_OPEN_VARIABLE_COLOUR_SPAN, 942 942 + r#"<span class="hljs-variable">"# 943 943 + ); 944 944 + const_zero_width_str!( 945 945 + ZERO_WIDTH_OPEN_TITLE_COLOUR_SPAN, 946 946 + r#"<span class="hljs-title">"# 947 947 + ); 948 948 + const_zero_width_str!( 949 949 + ZERO_WIDTH_OPEN_KEYWORD_COLOUR_SPAN, 950 950 + r#"<span class="hljs-keyword">"# 951 951 + ); 952 952 + const_zero_width_str!( 953 953 + ZERO_WIDTH_OPEN_COMMENT_COLOUR_SPAN, 954 954 + r#"<span class="hljs-comment">"# 955 955 + ); 917 956 918 957 const_break!(EMPTY_BREAK_DOCUMENT, "", ""); 919 958 const_break!(BREAKABLE_SPACE_DOCUMENT, "", " "); ··· 1239 1278 // We write the string, but do not increment the length 1240 1279 writer.write_str(string)?; 1241 1280 } 1281 1281 + PrintableDocument::ZeroWidthStr { string } => { 1282 1282 + // We write the string, but do not increment the length 1283 1283 + writer.write_str(string)?; 1284 1284 + } 1242 1285 1243 1286 // If multiple documents need to be printed, then they are all 1244 1287 // pushed to the front of the queue and will be printed one by one. ··· 1411 1454 1412 1455 // Zero width strings do nothing: they do not contribute to line length 1413 1456 PrintableDocument::ZeroWidthString { .. } 1457 1457 + | PrintableDocument::ZeroWidthStr { .. } 1414 1458 | PrintableDocument::CursorPositionObserver { .. } => {} 1415 1459 1416 1460 // If we get to a break we need to first see if it has to be