PageRenderTime 51ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/src/Boo.Lang.Compiler/CompilerErrorFactory.cs

https://github.com/boo/boo-lang
C# | 951 lines | 751 code | 175 blank | 25 comment | 14 complexity | 3d22e0eaf8df4306786bd7cabf3237e4 MD5 | raw file
Possible License(s): GPL-2.0
  1. #region license
  2. // Copyright (c) 2004, Rodrigo B. de Oliveira (rbo@acm.org)
  3. // All rights reserved.
  4. //
  5. // Redistribution and use in source and binary forms, with or without modification,
  6. // are permitted provided that the following conditions are met:
  7. //
  8. // * Redistributions of source code must retain the above copyright notice,
  9. // this list of conditions and the following disclaimer.
  10. // * Redistributions in binary form must reproduce the above copyright notice,
  11. // this list of conditions and the following disclaimer in the documentation
  12. // and/or other materials provided with the distribution.
  13. // * Neither the name of Rodrigo B. de Oliveira nor the names of its
  14. // contributors may be used to endorse or promote products derived from this
  15. // software without specific prior written permission.
  16. //
  17. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  18. // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19. // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20. // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  21. // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22. // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23. // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24. // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25. // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26. // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27. #endregion
  28. using Boo.Lang.Compiler.TypeSystem;
  29. namespace Boo.Lang.Compiler
  30. {
  31. using System;
  32. using System.Text;
  33. using Boo.Lang.Compiler.Ast;
  34. public class CompilerErrorFactory
  35. {
  36. private CompilerErrorFactory()
  37. {
  38. }
  39. public static CompilerError CustomError(LexicalInfo lexicalInfo, string msg)
  40. {
  41. return new CompilerError(lexicalInfo, msg);
  42. }
  43. public static CompilerError CustomError(string msg)
  44. {
  45. return new CompilerError(msg);
  46. }
  47. public static CompilerError ClassAlreadyHasBaseType(Node node, string className, string baseType)
  48. {
  49. return new CompilerError("BCE0001", SafeLexicalInfo(node), className, baseType);
  50. }
  51. public static CompilerError NamedParameterMustBeIdentifier(ExpressionPair pair)
  52. {
  53. return new CompilerError("BCE0002", SafeLexicalInfo(pair.First));
  54. }
  55. public static CompilerError NamedArgumentsNotAllowed(Node node)
  56. {
  57. return new CompilerError("BCE0003", SafeLexicalInfo(node));
  58. }
  59. public static CompilerError AmbiguousReference(ReferenceExpression reference, System.Reflection.MemberInfo[] members)
  60. {
  61. return new CompilerError("BCE0004",
  62. SafeLexicalInfo(reference),
  63. reference.Name,
  64. ToNameList(members)
  65. );
  66. }
  67. public static CompilerError AmbiguousReference(Node node, string name, System.Collections.IEnumerable names)
  68. {
  69. return new CompilerError("BCE0004", SafeLexicalInfo(node), name, ToStringList(names));
  70. }
  71. public static CompilerError UnknownIdentifier(Node node, string name)
  72. {
  73. return new CompilerError("BCE0005", SafeLexicalInfo(node), name);
  74. }
  75. public static CompilerError CantCastToValueType(Node node, string typeName)
  76. {
  77. return new CompilerError("BCE0006", SafeLexicalInfo(node), typeName);
  78. }
  79. public static CompilerError NotAPublicFieldOrProperty(Node node, string name, string typeName)
  80. {
  81. return new CompilerError("BCE0007", SafeLexicalInfo(node), typeName, name);
  82. }
  83. public static CompilerError MissingConstructor(Exception error, Node node, Type type, object[] parameters)
  84. {
  85. return new CompilerError("BCE0008", SafeLexicalInfo(node), error, type, GetSignature(parameters));
  86. }
  87. public static CompilerError AttributeApplicationError(Exception error, Boo.Lang.Compiler.Ast.Attribute attribute, Type attributeType)
  88. {
  89. return new CompilerError("BCE0009",
  90. attribute.LexicalInfo,
  91. error,
  92. attributeType,
  93. error.Message);
  94. }
  95. public static CompilerError AstAttributeMustBeExternal(Node node, string attributeType)
  96. {
  97. return new CompilerError("BCE0010", SafeLexicalInfo(node), attributeType);
  98. }
  99. public static CompilerError StepExecutionError(Exception error, ICompilerStep step)
  100. {
  101. return new CompilerError("BCE0011", error, step, error.Message);
  102. }
  103. public static CompilerError TypeMustImplementICompilerStep(string typeName)
  104. {
  105. return new CompilerError("BCE0012", LexicalInfo.Empty, typeName);
  106. }
  107. public static CompilerError AttributeNotFound(string elementName, string attributeName)
  108. {
  109. return new CompilerError("BCE0013", LexicalInfo.Empty, elementName, attributeName);
  110. }
  111. public static CompilerError InvalidAssemblySetUp(Node node)
  112. {
  113. return new CompilerError("BCE0014", SafeLexicalInfo(node));
  114. }
  115. public static CompilerError InvalidNode(Node node)
  116. {
  117. return new CompilerError("BCE0015", SafeLexicalInfo(node), node);
  118. }
  119. public static CompilerError MethodArgumentCount(Node node, string name, int count)
  120. {
  121. return new CompilerError("BCE0016", SafeLexicalInfo(node), name, count);
  122. }
  123. public static CompilerError MethodSignature(Node node, string expectedSignature, string actualSignature)
  124. {
  125. return new CompilerError("BCE0017", SafeLexicalInfo(node), expectedSignature, actualSignature);
  126. }
  127. public static CompilerError NameNotType(Node node, string name, string suggestion)
  128. {
  129. return new CompilerError("BCE0018", SafeLexicalInfo(node), name, DidYouMeanOrNull(suggestion));
  130. }
  131. public static CompilerError MemberNotFound(MemberReferenceExpression node, string namespace_, string suggestion)
  132. {
  133. return new CompilerError("BCE0019", SafeLexicalInfo(node), node.Name, namespace_, DidYouMeanOrNull(suggestion));
  134. }
  135. public static CompilerError InstanceRequired(Node node, string typeName, string memberName)
  136. {
  137. return new CompilerError("BCE0020", SafeLexicalInfo(node), typeName, memberName);
  138. }
  139. public static CompilerError InvalidNamespace(Import import)
  140. {
  141. return new CompilerError("BCE0021", import.LexicalInfo, import.Namespace);
  142. }
  143. public static CompilerError IncompatibleExpressionType(Node node, string expectedType, string actualType)
  144. {
  145. return new CompilerError("BCE0022", SafeLexicalInfo(node), expectedType, actualType);
  146. }
  147. public static CompilerError NoApropriateOverloadFound(Node node, string signature, string memberName)
  148. {
  149. return new CompilerError("BCE0023", SafeLexicalInfo(node), signature, memberName);
  150. }
  151. public static CompilerError NoApropriateConstructorFound(Node node, string typeName, string signature)
  152. {
  153. return new CompilerError("BCE0024", SafeLexicalInfo(node), typeName, signature);
  154. }
  155. public static CompilerError InvalidArray(Node node)
  156. {
  157. return new CompilerError("BCE0025", SafeLexicalInfo(node));
  158. }
  159. public static CompilerError BoolExpressionRequired(Node node, string typeName)
  160. {
  161. return new CompilerError("BCE0026", SafeLexicalInfo(node), typeName);
  162. }
  163. public static CompilerError NoEntryPoint()
  164. {
  165. return new CompilerError("BCE0028", LexicalInfo.Empty);
  166. }
  167. public static CompilerError MoreThanOneEntryPoint(Method method)
  168. {
  169. return new CompilerError("BCE0029", SafeLexicalInfo(method));
  170. }
  171. public static CompilerError NotImplemented(Node node, string message)
  172. {
  173. return new CompilerError("BCE0031", SafeLexicalInfo(node), message);
  174. }
  175. public static CompilerError EventArgumentMustBeAMethod(Node node, string eventName, string eventType)
  176. {
  177. return new CompilerError("BCE0032", SafeLexicalInfo(node), eventName, eventType);
  178. }
  179. public static CompilerError TypeNotAttribute(Node node, string attributeType)
  180. {
  181. return new CompilerError("BCE0033", SafeLexicalInfo(node), attributeType);
  182. }
  183. public static CompilerError ExpressionMustBeExecutedForItsSideEffects(Node node)
  184. {
  185. return new CompilerError("BCE0034", SafeLexicalInfo(node));
  186. }
  187. public static CompilerError ConflictWithInheritedMember(Node node, string member, string baseMember)
  188. {
  189. return new CompilerError("BCE0035", SafeLexicalInfo(node), member, baseMember);
  190. }
  191. public static CompilerError InvalidTypeof(Node node)
  192. {
  193. return new CompilerError("BCE0036", SafeLexicalInfo(node));
  194. }
  195. public static CompilerError UnknownMacro(Node node, string name)
  196. {
  197. return new CompilerError("BCE0037", SafeLexicalInfo(node), name);
  198. }
  199. public static CompilerError InvalidMacro(Node node, string name)
  200. {
  201. return new CompilerError("BCE0038", SafeLexicalInfo(node), name);
  202. }
  203. public static CompilerError AstMacroMustBeExternal(Node node, string typeName)
  204. {
  205. return new CompilerError("BCE0039", SafeLexicalInfo(node), typeName);
  206. }
  207. public static CompilerError UnableToLoadAssembly(Node node, string name, Exception error)
  208. {
  209. return new CompilerError("BCE0041", SafeLexicalInfo(node), error, name);
  210. }
  211. public static CompilerError InputError(string inputName, Exception error)
  212. {
  213. return new CompilerError("BCE0042", new LexicalInfo(inputName), error, inputName, error.Message);
  214. }
  215. public static CompilerError UnexpectedToken(LexicalInfo lexicalInfo, Exception error, string token)
  216. {
  217. return new CompilerError("BCE0043", lexicalInfo, error, token);
  218. }
  219. public static CompilerError GenericParserError(LexicalInfo lexicalInfo, Exception error)
  220. {
  221. return new CompilerError("BCE0044", lexicalInfo, error, error.Message);
  222. }
  223. public static CompilerError MacroExpansionError(Node node, Exception error)
  224. {
  225. return new CompilerError("BCE0045", SafeLexicalInfo(node), error, error.Message);
  226. }
  227. public static CompilerError OperatorCantBeUsedWithValueType(Node node, string operatorName, string typeName)
  228. {
  229. return new CompilerError("BCE0046", SafeLexicalInfo(node), operatorName, typeName);
  230. }
  231. public static CompilerError CantOverrideNonVirtual(Node node, string fullName)
  232. {
  233. return new CompilerError("BCE0047", SafeLexicalInfo(node), fullName);
  234. }
  235. public static CompilerError TypeDoesNotSupportSlicing(Node node, string fullName)
  236. {
  237. return new CompilerError("BCE0048", SafeLexicalInfo(node), fullName);
  238. }
  239. public static CompilerError LValueExpected(Node node)
  240. {
  241. return new CompilerError("BCE0049", SafeLexicalInfo(node));
  242. }
  243. public static CompilerError InvalidOperatorForType(Node node, string operatorName, string typeName)
  244. {
  245. return new CompilerError("BCE0050", SafeLexicalInfo(node), operatorName, typeName);
  246. }
  247. public static CompilerError InvalidOperatorForTypes(Node node, string operatorName, string lhs, string rhs)
  248. {
  249. return new CompilerError("BCE0051", SafeLexicalInfo(node), operatorName, lhs, rhs);
  250. }
  251. public static CompilerError InvalidLen(Node node, string typeName)
  252. {
  253. return new CompilerError("BCE0052", SafeLexicalInfo(node), typeName);
  254. }
  255. public static CompilerError PropertyIsReadOnly(Node node, string propertyName)
  256. {
  257. return new CompilerError("BCE0053", SafeLexicalInfo(node), propertyName);
  258. }
  259. public static CompilerError IsaArgument(Node node)
  260. {
  261. return new CompilerError("BCE0054", SafeLexicalInfo(node));
  262. }
  263. public static CompilerError InternalError(Node node, Exception error)
  264. {
  265. string message = error != null ? error.Message : string.Empty;
  266. return InternalError(node, message, error);
  267. }
  268. public static CompilerError InternalError(Node node, string message, Exception cause)
  269. {
  270. return new CompilerError("BCE0055", SafeLexicalInfo(node), cause, message);
  271. }
  272. public static CompilerError FileNotFound(string fname)
  273. {
  274. return new CompilerError("BCE0056", new LexicalInfo(fname), fname);
  275. }
  276. public static CompilerError CantRedefinePrimitive(Node node, string name)
  277. {
  278. return new CompilerError("BCE0057", SafeLexicalInfo(node), name);
  279. }
  280. public static CompilerError SelfIsNotValidInStaticMember(Node node)
  281. {
  282. return new CompilerError("BCE0058", SafeLexicalInfo(node));
  283. }
  284. public static CompilerError InvalidLockMacroArguments(Node node)
  285. {
  286. return new CompilerError("BCE0059", SafeLexicalInfo(node));
  287. }
  288. public static CompilerError NoMethodToOverride(Node node, string signature)
  289. {
  290. return new CompilerError("BCE0060", SafeLexicalInfo(node), signature);
  291. }
  292. public static CompilerError MethodIsNotOverride(Node node, string signature)
  293. {
  294. return new CompilerError("BCE0061", SafeLexicalInfo(node), signature);
  295. }
  296. public static CompilerError CouldNotInferReturnType(Node node, string signature)
  297. {
  298. return new CompilerError("BCE0062", SafeLexicalInfo(node), signature);
  299. }
  300. public static CompilerError NoEnclosingLoop(Node node)
  301. {
  302. return new CompilerError("BCE0063", SafeLexicalInfo(node));
  303. }
  304. public static CompilerError UnknownAttribute(Node node, string attributeName, string suggestion)
  305. {
  306. return new CompilerError("BCE0064", SafeLexicalInfo(node), attributeName, DidYouMeanOrNull(suggestion));
  307. }
  308. public static CompilerError InvalidIteratorType(Node node, string typeName)
  309. {
  310. return new CompilerError("BCE0065", SafeLexicalInfo(node), typeName);
  311. }
  312. public static CompilerError InvalidNodeForAttribute(LexicalInfo info, string attributeName, string expectedNodeTypes)
  313. {
  314. return new CompilerError("BCE0066", info, attributeName, expectedNodeTypes);
  315. }
  316. public static CompilerError LocalAlreadyExists(Node node, string name)
  317. {
  318. return new CompilerError("BCE0067", SafeLexicalInfo(node), name);
  319. }
  320. public static CompilerError PropertyRequiresParameters(Node node, string name)
  321. {
  322. return new CompilerError("BCE0068", SafeLexicalInfo(node), name);
  323. }
  324. public static CompilerError InterfaceCanOnlyInheritFromInterface(Node node, string interfaceName, string baseType)
  325. {
  326. return new CompilerError("BCE0069", SafeLexicalInfo(node), interfaceName, baseType);
  327. }
  328. public static CompilerError UnresolvedDependency(Node node, string source, string target)
  329. {
  330. return new CompilerError("BCE0070", SafeLexicalInfo(node), source, target);
  331. }
  332. public static CompilerError InheritanceCycle(Node node, string typeName)
  333. {
  334. return new CompilerError("BCE0071", SafeLexicalInfo(node), typeName);
  335. }
  336. public static CompilerError InvalidOverrideReturnType(Node node, string methodName, string expectedReturnType, string actualReturnType)
  337. {
  338. return new CompilerError("BCE0072", SafeLexicalInfo(node), methodName, expectedReturnType, actualReturnType);
  339. }
  340. public static CompilerError AbstractMethodCantHaveBody(Node node, string methodName)
  341. {
  342. return new CompilerError("BCE0073", SafeLexicalInfo(node), methodName);
  343. }
  344. public static CompilerError SelfOutsideMethod(Node node)
  345. {
  346. return new CompilerError("BCE0074", SafeLexicalInfo(node));
  347. }
  348. public static CompilerError NamespaceIsNotAnExpression(Node node, string name)
  349. {
  350. return new CompilerError("BCE0075", SafeLexicalInfo(node), name);
  351. }
  352. public static CompilerError RuntimeMethodBodyMustBeEmpty(Node node, string name)
  353. {
  354. return new CompilerError("BCE0076", SafeLexicalInfo(node), name);
  355. }
  356. public static CompilerError TypeIsNotCallable(Node node, string name)
  357. {
  358. return new CompilerError("BCE0077", SafeLexicalInfo(node), name);
  359. }
  360. public static CompilerError MethodReferenceExpected(Node node)
  361. {
  362. return new CompilerError("BCE0078", SafeLexicalInfo(node));
  363. }
  364. public static CompilerError AddressOfOutsideDelegateConstructor(Node node)
  365. {
  366. return new CompilerError("BCE0079", SafeLexicalInfo(node));
  367. }
  368. public static CompilerError BuiltinCannotBeUsedAsExpression(Node node, string name)
  369. {
  370. return new CompilerError("BCE0080", SafeLexicalInfo(node), name);
  371. }
  372. public static CompilerError ReRaiseOutsideExceptionHandler(Node node)
  373. {
  374. return new CompilerError("BCE0081", SafeLexicalInfo(node));
  375. }
  376. public static CompilerError EventTypeIsNotCallable(Node node, string typeName)
  377. {
  378. return new CompilerError("BCE0082", SafeLexicalInfo(node), typeName);
  379. }
  380. public static CompilerError StaticConstructorMustBePrivate(Node node)
  381. {
  382. return new CompilerError("BCE0083", SafeLexicalInfo(node));
  383. }
  384. public static CompilerError StaticConstructorCannotDeclareParameters(Node node)
  385. {
  386. return new CompilerError("BCE0084", SafeLexicalInfo(node));
  387. }
  388. public static CompilerError CantCreateInstanceOfAbstractType(Node node, string typeName)
  389. {
  390. return new CompilerError("BCE0085", SafeLexicalInfo(node), typeName);
  391. }
  392. public static CompilerError CantCreateInstanceOfInterface(Node node, string typeName)
  393. {
  394. return new CompilerError("BCE0086", SafeLexicalInfo(node), typeName);
  395. }
  396. public static CompilerError CantCreateInstanceOfEnum(Node node, string typeName)
  397. {
  398. return new CompilerError("BCE0087", SafeLexicalInfo(node), typeName);
  399. }
  400. public static CompilerError ReservedPrefix(Node node, string prefix)
  401. {
  402. return new CompilerError("BCE0088", SafeLexicalInfo(node), prefix);
  403. }
  404. public static CompilerError MemberNameConflict(Node node, string typeName, string memberName)
  405. {
  406. return new CompilerError("BCE0089", SafeLexicalInfo(node), typeName, memberName);
  407. }
  408. public static CompilerError DerivedMethodCannotReduceAccess(Node node, string derivedMethod, string superMethod, TypeMemberModifiers derivedAccess, TypeMemberModifiers superAccess)
  409. {
  410. return new CompilerError("BCE0090", SafeLexicalInfo(node), derivedMethod, superMethod, superAccess.ToString().ToLower(), derivedAccess.ToString().ToLower());
  411. }
  412. public static CompilerError EventIsNotAnExpression(Node node, string eventName)
  413. {
  414. return new CompilerError("BCE0091", SafeLexicalInfo(node), eventName);
  415. }
  416. public static CompilerError InvalidRaiseArgument(Node node, string typeName)
  417. {
  418. return new CompilerError("BCE0092", SafeLexicalInfo(node), typeName);
  419. }
  420. public static CompilerError CannotBranchIntoEnsure(Node node)
  421. {
  422. return new CompilerError("BCE0093", SafeLexicalInfo(node));
  423. }
  424. public static CompilerError CannotBranchIntoExcept(Node node)
  425. {
  426. return new CompilerError("BCE0094", SafeLexicalInfo(node));
  427. }
  428. public static CompilerError NoSuchLabel(Node node, string label)
  429. {
  430. return new CompilerError("BCE0095", SafeLexicalInfo(node), label);
  431. }
  432. public static CompilerError LabelAlreadyDefined(Node node, string methodName, string label)
  433. {
  434. return new CompilerError("BCE0096", SafeLexicalInfo(node), methodName, label);
  435. }
  436. public static CompilerError CannotBranchIntoTry(Node node)
  437. {
  438. return new CompilerError("BCE0097", SafeLexicalInfo(node));
  439. }
  440. public static CompilerError InvalidSwitch(Node node)
  441. {
  442. return new CompilerError("BCE0098", SafeLexicalInfo(node));
  443. }
  444. public static CompilerError YieldInsideTryExceptOrEnsureBlock(Node node)
  445. {
  446. return new CompilerError("BCE0099", SafeLexicalInfo(node));
  447. }
  448. public static CompilerError YieldInsideConstructor(Node node)
  449. {
  450. return new CompilerError("BCE0100", SafeLexicalInfo(node));
  451. }
  452. public static CompilerError InvalidGeneratorReturnType(Node node)
  453. {
  454. return new CompilerError("BCE0101", SafeLexicalInfo(node));
  455. }
  456. public static CompilerError GeneratorCantReturnValue(Node node)
  457. {
  458. return new CompilerError("BCE0102", SafeLexicalInfo(node));
  459. }
  460. public static CompilerError CannotExtendFinalType(Node node, string typeName)
  461. {
  462. return new CompilerError("BCE0103", SafeLexicalInfo(node), typeName);
  463. }
  464. public static CompilerError CantBeMarkedTransient(Node node)
  465. {
  466. return new CompilerError("BCE0104", SafeLexicalInfo(node));
  467. }
  468. public static CompilerError CantBeMarkedAbstract(Node node)
  469. {
  470. return new CompilerError("BCE0105", SafeLexicalInfo(node));
  471. }
  472. public static CompilerError FailedToLoadTypesFromAssembly(string assemblyName, Exception x)
  473. {
  474. return new CompilerError("BCE0106", LexicalInfo.Empty, x, assemblyName);
  475. }
  476. public static CompilerError ValueTypesCannotDeclareParameterlessConstructors(Node node)
  477. {
  478. return new CompilerError("BCE0107", SafeLexicalInfo(node));
  479. }
  480. public static CompilerError ValueTypeFieldsCannotHaveInitializers(Node node)
  481. {
  482. return new CompilerError("BCE0108", SafeLexicalInfo(node));
  483. }
  484. public static CompilerError InvalidArrayRank(Node node, string arrayName, int real, int given)
  485. {
  486. return new CompilerError("BCE0109", SafeLexicalInfo(node), arrayName, real, given);
  487. }
  488. public static CompilerError NotANamespace(Node node, string name)
  489. {
  490. return new CompilerError("BCE0110", SafeLexicalInfo(node), name);
  491. }
  492. public static CompilerError InvalidDestructorModifier(Node node)
  493. {
  494. return new CompilerError("BCE0111", SafeLexicalInfo(node));
  495. }
  496. public static CompilerError CantHaveDestructorParameters(Node node)
  497. {
  498. return new CompilerError("BCE0112", SafeLexicalInfo(node));
  499. }
  500. public static CompilerError InvalidCharLiteral(Node node, string value)
  501. {
  502. return new CompilerError("BCE0113", SafeLexicalInfo(node), value);
  503. }
  504. public static CompilerError InvalidInterfaceForInterfaceMember(Node node, string value)
  505. {
  506. return new CompilerError("BCE0114", SafeLexicalInfo(node), value);
  507. }
  508. public static CompilerError InterfaceImplForInvalidInterface(Node node, string iface, string item)
  509. {
  510. return new CompilerError("BCE0115", SafeLexicalInfo(node), iface, item);
  511. }
  512. public static CompilerError ExplicitImplMustNotHaveModifiers(Node node, string iface, string item)
  513. {
  514. return new CompilerError("BCE0116", SafeLexicalInfo(node), iface, item);
  515. }
  516. public static CompilerError FieldIsReadonly(Node node, string name)
  517. {
  518. return new CompilerError("BCE0117", SafeLexicalInfo(node), name);
  519. }
  520. public static CompilerError ExplodedExpressionMustBeArray(Node node)
  521. {
  522. return new CompilerError("BCE0118", SafeLexicalInfo(node));
  523. }
  524. public static CompilerError ExplodeExpressionMustMatchVarArgCall(Node node)
  525. {
  526. return new CompilerError("BCE0119", SafeLexicalInfo(node));
  527. }
  528. public static CompilerError UnaccessibleMember(Node node, string name)
  529. {
  530. return new CompilerError("BCE0120", SafeLexicalInfo(node), name);
  531. }
  532. public static CompilerError InvalidSuper(Node node)
  533. {
  534. return new CompilerError("BCE0121", SafeLexicalInfo(node));
  535. }
  536. public static CompilerError ValueTypeCantHaveAbstractMember(Node node, string typeName, string memberName)
  537. {
  538. return new CompilerError("BCE0122", SafeLexicalInfo(node), typeName, memberName);
  539. }
  540. public static CompilerError InvalidParameterType(Node node, string typeName)
  541. {
  542. return new CompilerError("BCE0123", SafeLexicalInfo(node), typeName);
  543. }
  544. public static CompilerError InvalidFieldType(Node node, string typeName)
  545. {
  546. return new CompilerError("BCE0124", SafeLexicalInfo(node), typeName);
  547. }
  548. public static CompilerError InvalidDeclarationType(Node node, string typeName)
  549. {
  550. return new CompilerError("BCE0125", SafeLexicalInfo(node), typeName);
  551. }
  552. public static CompilerError InvalidExpressionType(Node node, string typeName)
  553. {
  554. return new CompilerError("BCE0126", SafeLexicalInfo(node), typeName);
  555. }
  556. public static CompilerError RefArgTakesLValue(Node node)
  557. {
  558. return new CompilerError("BCE0127", SafeLexicalInfo(node), node.ToString());
  559. }
  560. public static CompilerError InvalidTryStatement(Node node)
  561. {
  562. return new CompilerError("BCE0128", SafeLexicalInfo(node));
  563. }
  564. public static CompilerError InvalidExtensionDefinition(Node node)
  565. {
  566. return new CompilerError("BCE0129", SafeLexicalInfo(node));
  567. }
  568. public static CompilerError CantBeMarkedPartial(Node node)
  569. {
  570. return new CompilerError("BCE0130", SafeLexicalInfo(node));
  571. }
  572. public static CompilerError InvalidCombinationOfModifiers(Node node, string name, string modifiers)
  573. {
  574. return new CompilerError("BCE0131", SafeLexicalInfo(node), name, modifiers);
  575. }
  576. public static CompilerError NamespaceAlreadyContainsMember(Node node, string container, string member)
  577. {
  578. return new CompilerError("BCE0132", SafeLexicalInfo(node), container, member);
  579. }
  580. public static CompilerError InvalidEntryPoint(Node node)
  581. {
  582. return new CompilerError("BCE0133", SafeLexicalInfo(node));
  583. }
  584. public static CompilerError CannotReturnValue(Method node)
  585. {
  586. return new CompilerError("BCE0134", SafeLexicalInfo(node), node);
  587. }
  588. public static CompilerError InvalidName(Node node, string name)
  589. {
  590. return new CompilerError("BCE0135", SafeLexicalInfo(node), name);
  591. }
  592. public static CompilerError ColonInsteadOfEquals(Node node)
  593. {
  594. return new CompilerError("BCE0136", SafeLexicalInfo(node));
  595. }
  596. public static CompilerError PropertyIsWriteOnly(Node node, string propertyName)
  597. {
  598. return new CompilerError("BCE0137", SafeLexicalInfo(node), propertyName);
  599. }
  600. public static CompilerError NotAGenericDefinition(Node node, string name)
  601. {
  602. return new CompilerError("BCE0138", SafeLexicalInfo(node), name);
  603. }
  604. public static CompilerError GenericDefinitionArgumentCount(Node node, string name, int expectedCount)
  605. {
  606. return new CompilerError("BCE0139", SafeLexicalInfo(node), name, expectedCount);
  607. }
  608. public static CompilerError YieldTypeDoesNotMatchReturnType(Node node, string yieldType, string returnType)
  609. {
  610. return new CompilerError("BCE0140", SafeLexicalInfo(node), yieldType, returnType);
  611. }
  612. public static CompilerError DuplicateParameterName(Node node, string parameter, string method)
  613. {
  614. return new CompilerError("BCE0141", SafeLexicalInfo(node), parameter, method);
  615. }
  616. public static CompilerError ValueTypeParameterCannotUseDefaultAttribute(Node node, string parameter)
  617. {
  618. string method = (null != node as Method) ? (node as Method).Name : (node as Property).Name;
  619. return new CompilerError("BCE0142", SafeLexicalInfo(node), parameter, method);
  620. }
  621. public static CompilerError CantReturnFromEnsure(Node node)
  622. {
  623. return new CompilerError("BCE0143", SafeLexicalInfo(node));
  624. }
  625. public static CompilerError Obsolete(Node node, string memberName, string message)
  626. {
  627. return new CompilerError("BCE0144", SafeLexicalInfo(node), memberName, message);
  628. }
  629. public static CompilerError InvalidExceptArgument(Node node, string exceptionType)
  630. {
  631. return new CompilerError("BCE0145", SafeLexicalInfo(node), exceptionType);
  632. }
  633. public static CompilerError GenericArgumentMustBeReferenceType(Node node, IGenericParameter parameter, IType argument)
  634. {
  635. return new CompilerError("BCE0146", SafeLexicalInfo(node), argument, parameter);
  636. }
  637. public static CompilerError GenericArgumentMustBeValueType(Node node, IGenericParameter parameter, IType argument)
  638. {
  639. return new CompilerError("BCE0147", SafeLexicalInfo(node), argument, parameter);
  640. }
  641. public static CompilerError GenericArgumentMustHaveDefaultConstructor(Node node, IGenericParameter parameter, IType argument)
  642. {
  643. return new CompilerError("BCE0148", SafeLexicalInfo(node), argument, parameter);
  644. }
  645. public static CompilerError GenericArgumentMustHaveBaseType(Node node, IGenericParameter parameter, IType argument, IType baseType)
  646. {
  647. return new CompilerError("BCE0149", SafeLexicalInfo(node), argument, parameter, baseType);
  648. }
  649. public static CompilerError CantBeMarkedFinal(Node node)
  650. {
  651. return new CompilerError("BCE0150", SafeLexicalInfo(node));
  652. }
  653. public static CompilerError CantBeMarkedStatic(Node node)
  654. {
  655. return new CompilerError("BCE0151", SafeLexicalInfo(node));
  656. }
  657. public static CompilerError ConstructorCantBePolymorphic(Node node, string memberName)
  658. {
  659. return new CompilerError("BCE0152", SafeLexicalInfo(node), memberName);
  660. }
  661. public static CompilerError InvalidAttributeTarget(Node node, Type attrType, AttributeTargets validOn)
  662. {
  663. return new CompilerError("BCE0153", SafeLexicalInfo(node), attrType, validOn);
  664. }
  665. public static CompilerError MultipleAttributeUsage(Node node, Type attrType)
  666. {
  667. return new CompilerError("BCE0154", SafeLexicalInfo(node), attrType);
  668. }
  669. public static CompilerError CannotCreateAnInstanceOfGenericParameterWithoutDefaultConstructorConstraint(Node node, string type)
  670. {
  671. return new CompilerError("BCE0155", SafeLexicalInfo(node), type);
  672. }
  673. public static CompilerError EventCanOnlyBeInvokedFromWithinDeclaringClass(Node node, IEvent ev)
  674. {
  675. return new CompilerError("BCE0156", SafeLexicalInfo(node), ev.Name, ev.DeclaringType);
  676. }
  677. public static CompilerError GenericTypesMustBeConstructedToBeInstantiated(Node node)
  678. {
  679. return new CompilerError("BCE0157", SafeLexicalInfo(node));
  680. }
  681. public static CompilerError InstanceMethodInvocationBeforeInitialization(Constructor ctor, MemberReferenceExpression mre)
  682. {
  683. return new CompilerError("BCE0158", SafeLexicalInfo(mre), mre.Name);
  684. }
  685. public static CompilerError StructAndClassConstraintsConflict(GenericParameterDeclaration gpd)
  686. {
  687. return new CompilerError("BCE0159", SafeLexicalInfo(gpd), gpd.Name);
  688. }
  689. public static CompilerError StructAndConstructorConstraintsConflict(GenericParameterDeclaration gpd)
  690. {
  691. return new CompilerError("BCE0160", SafeLexicalInfo(gpd), gpd.Name);
  692. }
  693. public static CompilerError TypeConstraintConflictsWithSpecialConstraint(GenericParameterDeclaration gpd, TypeReference type, string constraint)
  694. {
  695. return new CompilerError("BCE0161", SafeLexicalInfo(type), gpd.Name, type, constraint);
  696. }
  697. public static CompilerError InvalidTypeConstraint(GenericParameterDeclaration gpd, TypeReference type)
  698. {
  699. return new CompilerError("BCE0162", SafeLexicalInfo(type), gpd.Name, type);
  700. }
  701. public static CompilerError MultipleBaseTypeConstraints(GenericParameterDeclaration gpd, TypeReference type, TypeReference other)
  702. {
  703. return new CompilerError("BCE0163", SafeLexicalInfo(type), gpd.Name, type, other);
  704. }
  705. public static CompilerError CannotInferGenericMethodArguments(MethodInvocationExpression node, IMethod method)
  706. {
  707. return new CompilerError("BCE0164", SafeLexicalInfo(node), method);
  708. }
  709. public static string ToStringList(System.Collections.IEnumerable names)
  710. {
  711. StringBuilder builder = new StringBuilder();
  712. foreach (object name in names)
  713. {
  714. if (builder.Length > 0)
  715. {
  716. builder.Append(", ");
  717. }
  718. builder.Append(name.ToString());
  719. }
  720. return builder.ToString();
  721. }
  722. public static string ToAssemblyQualifiedNameList(List types)
  723. {
  724. StringBuilder builder = new StringBuilder();
  725. builder.Append(((Type)types[0]).AssemblyQualifiedName);
  726. for (int i=1; i<types.Count; ++i)
  727. {
  728. builder.Append(", ");
  729. builder.Append(((Type)types[i]).AssemblyQualifiedName);
  730. }
  731. return builder.ToString();
  732. }
  733. public static string GetSignature(object[] parameters)
  734. {
  735. StringBuilder sb = new StringBuilder("(");
  736. for (int i=0; i<parameters.Length; ++i)
  737. {
  738. if (i>0)
  739. {
  740. sb.Append(", ");
  741. }
  742. if (null != parameters)
  743. {
  744. sb.Append(parameters[i].GetType());
  745. }
  746. }
  747. sb.Append(")");
  748. return sb.ToString();
  749. }
  750. public static string ToNameList(System.Reflection.MemberInfo[] members)
  751. {
  752. StringBuilder sb = new StringBuilder();
  753. for (int i=0; i<members.Length; ++i)
  754. {
  755. if (i>0) { sb.Append(", "); }
  756. sb.Append(members[i].MemberType.ToString());
  757. sb.Append(" ");
  758. sb.Append(members[i].Name);
  759. }
  760. return sb.ToString();
  761. }
  762. private static LexicalInfo SafeLexicalInfo(Node node)
  763. {
  764. if (null == node) return Boo.Lang.Compiler.Ast.LexicalInfo.Empty;
  765. LexicalInfo info = node.LexicalInfo;
  766. if (info.IsValid) return info;
  767. return SafeLexicalInfo(node.ParentNode);
  768. }
  769. private static string DidYouMeanOrNull(string suggestion)
  770. {
  771. return (null != suggestion)
  772. ? ResourceManager.Format("BooC.DidYouMean", suggestion)
  773. : null;
  774. }
  775. }
  776. }