Details

    • Type: New Feature New Feature
    • Status: Resolved Resolved
    • Priority: Major Major
    • Resolution: Fixed
    • Affects Version/s: 0.8.2
    • Fix Version/s: 0.9
    • Component/s: Compiler
    • Labels:
      None
    • Number of attachments :
      0

      Description

      Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

      Strict mode introduces more conservative(safer) defaults and warnings.
      Strict mode is disabled by default.

      This compiler option is settable through:

      • "-strict" with booc
      • programatically by setting CompilerParameters.Strict to true
      • "strict" argument with nant and msbuild tasks

      When strict mode is enabled the following changes are enabled:

      • default visibility is private like in C# (change made through BOO-1091)
      • methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage] (BOO-1132)
      • warns if a variable has the same name as a private field of one of its super types (BOO-1133).
      • implicit return statement fires a warning (BOO-703)

      TODO:

      • implicit downcast fires a warning (BOO-943) — default mode? or strict mode only?

        Issue Links

          Activity

          Cedric Vivier made changes -
          Field Original Value New Value
          Link This issue supercedes BOO-943 [ BOO-943 ]
          Cedric Vivier made changes -
          Link This issue supercedes BOO-1092 [ BOO-1092 ]
          Cedric Vivier made changes -
          Link This issue relates to BOO-1091 [ BOO-1091 ]
          Cedric Vivier made changes -
          Link This issue relates to BOO-1091 [ BOO-1091 ]
          Cedric Vivier made changes -
          Link This issue depends upon BOO-1091 [ BOO-1091 ]
          Cedric Vivier made changes -
          Description For a number of Boo users, sometimes Boo is not conservative enough on certain defaults (which makes sense for others) that can make some errors slip through a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          Compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type must be explicitely declared
          - field naming recommendations are enforced (ie. _-prefix on non-visible fields), this enforces consistency and unnoticed conflict/behavior-change with variables which have same name than a field.
          - implicit downcast fires a warning (BOO-943)
          Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type must be explicitely declared
          - field naming recommendations are enforced (ie. _-prefix on non-visible fields), this enforces consistency and ensure no unnoticed conflict/behavior-change with variables which have same name than a field.
          - implicit downcast fires a warning (BOO-943)
          Cedric Vivier made changes -
          Link This issue is related to BOO-692 [ BOO-692 ]
          Cedric Vivier made changes -
          Link This issue depends upon BOO-703 [ BOO-703 ]
          Cedric Vivier made changes -
          Description Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type must be explicitely declared
          - field naming recommendations are enforced (ie. _-prefix on non-visible fields), this enforces consistency and ensure no unnoticed conflict/behavior-change with variables which have same name than a field.
          - implicit downcast fires a warning (BOO-943)
          Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type must be explicitely declared
          - field naming recommendations are enforced (ie. _-prefix on non-visible fields), this enforces consistency and ensure no unnoticed conflict/behavior-change with variables which have same name than a field.
          - implicit downcast fires a warning (BOO-943)
          - implicit return statement fires a warning (BOO-703)
          Cedric Vivier made changes -
          Link This issue is related to BOO-1087 [ BOO-1087 ]
          Cedric Vivier made changes -
          Description Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type must be explicitely declared
          - field naming recommendations are enforced (ie. _-prefix on non-visible fields), this enforces consistency and ensure no unnoticed conflict/behavior-change with variables which have same name than a field.
          - implicit downcast fires a warning (BOO-943)
          - implicit return statement fires a warning (BOO-703)
          Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks

          In effect, it adds a StrictModeCheckingStep into the pipeline.


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type must be explicitely declared
          - field naming recommendations are enforced (ie. _-prefix on non-visible fields), this enforces consistency and ensure no unnoticed conflict/behavior-change with variables which have same name than a field.
          - implicit downcast fires a warning (BOO-943)
          - implicit return statement fires a warning (BOO-703)
          Cedric Vivier made changes -
          Status Open [ 1 ] In Progress [ 3 ]
          Rodrigo B. de Oliveira made changes -
          Fix Version/s 0.9 [ 13816 ]
          Fix Version/s 0.9.1 [ 14922 ]
          Cedric Vivier made changes -
          Description Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks

          In effect, it adds a StrictModeCheckingStep into the pipeline.


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type must be explicitely declared
          - field naming recommendations are enforced (ie. _-prefix on non-visible fields), this enforces consistency and ensure no unnoticed conflict/behavior-change with variables which have same name than a field.
          - implicit downcast fires a warning (BOO-943)
          - implicit return statement fires a warning (BOO-703)
          Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks

          In effect, it adds a StrictModeCheckingStep into the pipeline.


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage]
          - warns if a variable cannot have the same name as a field of its declaring type (or one of its super types).
          - implicit return statement fires a warning (BOO-703)

          - implicit downcast fires a warning (BOO-943) --- default mode? or strict mode only?
          Cedric Vivier made changes -
          Fix Version/s 0.9.1 [ 14922 ]
          Fix Version/s 0.9 [ 13816 ]
          Cedric Vivier made changes -
          Description Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Introducing a strict mode would be a nice new feature to introduce and enforce more conservative(safer) defaults if desired.

          Strict mode is disabled by default.
          This compiler option would be settable through:
          - "-strict+" on booc
          - CompilerParameters.Strict as bool
          - "strict" argument in nant and msbuild tasks

          In effect, it adds a StrictModeCheckingStep into the pipeline.


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage]
          - warns if a variable cannot have the same name as a field of its declaring type (or one of its super types).
          - implicit return statement fires a warning (BOO-703)

          - implicit downcast fires a warning (BOO-943) --- default mode? or strict mode only?
          Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Strict mode introduces more conservative(safer) defaults and warnings.
          Strict mode is disabled by default.

          This compiler option is settable through:
          - "-strict" with booc
          - programatically by setting CompilerParameters.Strict to true
          - "strict" argument with nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage]
          - warns if a variable has the same name as a field of its declaring type (or one of its super types).
          - implicit return statement fires a warning (BOO-703)

          TODO:
          - implicit downcast fires a warning (BOO-943) --- default mode? or strict mode only?
          Cedric Vivier made changes -
          Description Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Strict mode introduces more conservative(safer) defaults and warnings.
          Strict mode is disabled by default.

          This compiler option is settable through:
          - "-strict" with booc
          - programatically by setting CompilerParameters.Strict to true
          - "strict" argument with nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage]
          - warns if a variable has the same name as a field of its declaring type (or one of its super types).
          - implicit return statement fires a warning (BOO-703)

          TODO:
          - implicit downcast fires a warning (BOO-943) --- default mode? or strict mode only?
          Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Strict mode introduces more conservative(safer) defaults and warnings.
          Strict mode is disabled by default.

          This compiler option is settable through:
          - "-strict" with booc
          - programatically by setting CompilerParameters.Strict to true
          - "strict" argument with nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage] (BOO-1132)
          - warns if a variable has the same name as a field of its declaring type (or one of its super types).
          - implicit return statement fires a warning (BOO-703)

          TODO:
          - implicit downcast fires a warning (BOO-943) --- default mode? or strict mode only?
          Cedric Vivier made changes -
          Link This issue depends upon BOO-1132 [ BOO-1132 ]
          Cedric Vivier made changes -
          Description Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Strict mode introduces more conservative(safer) defaults and warnings.
          Strict mode is disabled by default.

          This compiler option is settable through:
          - "-strict" with booc
          - programatically by setting CompilerParameters.Strict to true
          - "strict" argument with nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage] (BOO-1132)
          - warns if a variable has the same name as a field of its declaring type (or one of its super types).
          - implicit return statement fires a warning (BOO-703)

          TODO:
          - implicit downcast fires a warning (BOO-943) --- default mode? or strict mode only?
          Sometimes Boo is not conservative enough on certain defaults (which still makes sense for other/prototyping usages) that can lead to some errors slipping to a release unnoticed in (large) projects.

          Strict mode introduces more conservative(safer) defaults and warnings.
          Strict mode is disabled by default.

          This compiler option is settable through:
          - "-strict" with booc
          - programatically by setting CompilerParameters.Strict to true
          - "strict" argument with nant and msbuild tasks


          When strict mode is enabled the following changes are enabled:
          - default visibility is private like in C# (change made through BOO-1091)
          - methods parameters types and return type of public methods (API) must be explicitely declared [to avoid unnoticed/unwanted binary-compat breakage] (BOO-1132)
          - warns if a variable has the same name as a private field of one of its super types (BOO-1133).
          - implicit return statement fires a warning (BOO-703)

          TODO:
          - implicit downcast fires a warning (BOO-943) --- default mode? or strict mode only?
          Cedric Vivier made changes -
          Link This issue depends upon BOO-1133 [ BOO-1133 ]
          Cedric Vivier made changes -
          Resolution Fixed [ 1 ]
          Status In Progress [ 3 ] Resolved [ 5 ]

            People

            • Assignee:
              Cedric Vivier
              Reporter:
              Cedric Vivier
            • Votes:
              0 Vote for this issue
              Watchers:
              0 Start watching this issue

              Dates

              • Created:
                Updated:
                Resolved: